config

type AgentCollectionState string

type AgentDiscoveryReport struct {
	Files         []LoadedAgentFile
	Diagnostics   []AgentFileDiagnostic
	Warnings      []string
	Collection    AgentCollectionState
	UserDirectory string
	WorkspaceDir  string
}

type AgentFileDiagnostic struct {
	Name   string
	Source AgentSource
	Path   string
	State  AgentFileState
}

type AgentFileSettings struct {
	Name        string
	Description string
	Provider    string
	Model       string
	Tools       []string
	Skills      []string
	MCPServers  []string
}

type AgentFileSpec struct {
	Name        *string
	Description *string
	Inherits    *string
	Tools       *[]string
	// AllowEmptyTools permits an explicitly declared empty tools list. It is
	// valid only for a standalone agent with tools = [].
	AllowEmptyTools *bool
	ToolsAdd        *[]string
	ToolsRemove     *[]string
	DisallowedTools *[]string
	// ToolsCore overrides [tools] core for this agent (plan tools/05).
	// nil = inherit (parent's decision, else the global [tools] core).
	ToolsCore *[]string
	// Skills is the skill invocation allowlist for this agent (plan 06).
	// nil = omit (root: all trusted skills; inherited: parent decision);
	// non-nil empty = none; non-nil with names = those skills only.
	Skills *[]string
	// MCPServers is the MCP server allowlist. nil inherits the root default or
	// parent list. An explicit empty list denies every MCP server.
	MCPServers *[]string
	// Provider is the built-in provider name owning Model. It is normalized to
	// lower case at parse time and may only be set together with Model: a
	// provider alone would silently pair a foreign endpoint with the session's
	// model name. Provider selection on a workspace definition is ignored
	// unless the operator enables AllowWorkspaceAgentProviders (credential-
	// routing protection); user definitions always honor it.
	Provider *string
	Model    *string
	MaxTurns *int
	// TimeoutSeconds and MaxTokens are per-agent resource ceilings, deliberately
	// independent of MaxTurns: max_turns = 0 means unlimited iterations, not
	// unlimited wall-clock time or provider spend. nil = inherit the session's.
	TimeoutSeconds *int
	MaxTokens      *int
	SystemPrompt   *string
	// OutputSchema is an optional JSON Schema for the agent's final reply
	// (plan tools/02). Pointer preserves omit vs empty for inheritance.
	OutputSchema *map[string]any
	// InputSchema optionally validates task input at admission.
	InputSchema *map[string]any
}

type AgentFileState string

type AgentSource string

type AgentsGlobal struct {
	// LoadWorkspaceConfig enables workspace agent files and related
	// workspace-controlled prompt/skill surfaces. Default true.
	LoadWorkspaceConfig bool
	// AllowWorkspaceAgentProviders, when true, lets a workspace-sourced agent
	// definition select a (provider, model) binding. This is an operator opt-in
	// that accepts a real credential-routing risk: a checked-out repository
	// could route the operator's prompts, tool results, and file contents to
	// another vendor's endpoint authenticated with the operator's own
	// credentials. When false (the default), a workspace agent's
	// provider/model selection is ignored at resolve time (credential-routing
	// protection) and the agent inherits the session provider. Only the user
	// [agents] section may set this; workspace [agents] is never authoritative.
	AllowWorkspaceAgentProviders bool
	// RequireExplicitTools, when true, forces authored agents that omit tools
	// to resolve an empty allowlist (deny-by-default). Default false.
	RequireExplicitTools bool
	// FailOnEmptyToolset refuses an agent whose effective toolset is empty.
	// Default true so a typo cannot publish a no-tool agent silently.
	FailOnEmptyToolset bool
	// MandatoryToolDenylistAdditions are operator additions on top of the
	// compiled mandatory denylist. Config may only add; never remove baseline.
	MandatoryToolDenylistAdditions []string
	// Warnings are non-fatal diagnostics (e.g. workspace [agents] ignored).
	Warnings []string
	// Path is the user config file that supplied these values (may be empty).
	Path string
}

type ApprovalsConfig struct {
	Policy      string `toml:"policy"`
	DefaultMode string `toml:"default_mode"`
}

type ChatConfig struct {
	SystemPrompt    string `toml:"system_prompt"`
	MaxPromptTokens *int   `toml:"max_prompt_tokens"`
	// MaxContextTokens is retained only as a decode sentinel so the removed
	// setting cannot silently change the prompt safety budget.
	MaxContextTokens *int     `toml:"max_context_tokens"`
	Temperature      *float64 `toml:"temperature"`
	MaxTokens        *int     `toml:"max_tokens"`
	// MaxSteps bounds one interactive turn's agent loop. Unset uses the
	// built-in default; 0 means unlimited, which lets a model stuck emitting
	// tool calls run until the user interrupts it. /steps overrides per session.
	MaxSteps *int `toml:"max_steps"`
	// ShowIterationNotices controls whether per-step/iteration notices (e.g. "iteration 1")
	// are emitted in the TUI chat. Default: false (disabled).
	ShowIterationNotices *bool `toml:"show_iteration_notices"`
	// ShowPromptCacheNotices controls whether prompt cache hit/usage notices
	// are emitted in the TUI chat. Default: false (disabled).
	ShowPromptCacheNotices *bool `toml:"show_prompt_cache_notices"`
}

type ContextConfig struct {
	// MaxSourceEventBytes bounds one projected message's payload.
	MaxSourceEventBytes int `toml:"max_source_event_bytes"`
	// MaxCheckpointBytes bounds a checkpoint's serialized active context.
	MaxCheckpointBytes int `toml:"max_checkpoint_bytes"`
	// MaxCommitEvents bounds how many messages one turn may publish.
	MaxCommitEvents int `toml:"max_commit_events"`
	// MaxCommitEventBytes bounds one turn's aggregate payload bytes.
	MaxCommitEventBytes int `toml:"max_commit_event_bytes"`
	// MaxSessionStateBytes bounds a stored session's serialized messages.
	MaxSessionStateBytes int `toml:"max_session_state_bytes"`
	// MaxExportBytes bounds a context export.
	MaxExportBytes int `toml:"max_export_bytes"`
	// SummaryMetadataBytes bounds the persisted summary envelope. Zero (uncapped
	// by default) means the host imposes no compiled-in ceiling on
	// model-generated summary content.
	SummaryMetadataBytes int `toml:"summary_metadata_bytes"`
	// CheckpointMetadataBytes bounds the summary_metadata column within a
	// checkpoint record. Zero means uncapped.
	CheckpointMetadataBytes int `toml:"checkpoint_metadata_bytes"`
	// Summary is the [context.summary] policy sub-table. Unlike the numeric
	// ceilings above, it is behavior policy, not a storage bound.
	Summary ContextSummaryConfig `toml:"summary"`
}

type ContextSummaryConfig struct {
	// Enabled turns on the bounded provider call that summarizes what
	// compaction dropped. Nil means unset, which resolves to true - the
	// pointer exists precisely so an explicit `enabled = false` is
	// distinguishable from an absent key, which a plain bool cannot express.
	// The call still requires a resolved provider endpoint; without one the
	// summary stays off and summaryDisabledReason names why.
	Enabled *bool `toml:"enabled"`

	// Provider and Model override the binding the summary call runs on,
	// allowing summaries to use a cheaper model than the session binding.
	// Both keys must be set together, and Provider must be a known provider
	// declared under [providers] - the model is not required to appear in
	// that provider's declared models (agent-file precedent: a bad model
	// degrades at call time, and summary failures are intentionally soft).
	// Absent means the summary uses the session binding captured at setup.
	Provider *string `toml:"provider"`
	Model    *string `toml:"model"`
}

type File struct {
	EnvFile      string                    `toml:"env_file"`
	Provider     ProviderSection           `toml:"provider"`
	Providers    map[string]ProviderConfig `toml:"providers"`
	Chat         ChatConfig                `toml:"chat"`
	Subagents    SubagentConfig            `toml:"subagents"`
	Worktrees    WorktreeConfig            `toml:"worktrees"`
	Tools        ToolsConfig               `toml:"tools"`
	Privacy      PrivacyConfig             `toml:"privacy"`
	Context      ContextConfig             `toml:"context"`
	Integrations IntegrationsConfig        `toml:"integrations"`
	MCP          MCPConfig                 `toml:"mcp"`
	Memory       MemoryConfig              `toml:"memory"`
	Harness      HarnessConfig             `toml:"harness"`
	Approvals    ApprovalsConfig           `toml:"approvals"`
	TUI          TUIConfig                 `toml:"tui"`
	Workflows    WorkflowsConfig           `toml:"workflows"`
	// Verifiers is populated by LoadWorkspaceVerifiers from the WORKSPACE'S
	// own .mivia/mivia.toml only (loadFile), never by the tolerant struct
	// decode and never from a user-level base layer: a verifier table with an
	// unknown key must fail the load, and the profiles that judge a project's
	// gates must come from that project's file alone.
	Verifiers map[string]VerifierProfile `toml:"-"`
}

type GeneralSettings struct {
	Theme                  string
	Mouse                  bool
	ShowReasoning          bool
	ShowIterationNotices   bool
	ShowPromptCacheNotices bool
	ScrollLines            int
	ApprovalDefault        string
	ScreenReader           bool
	ReducedMotion          bool
}

type HarnessConfig struct {
	// Sandbox controls whether the harness runs verifier/evidence-gate
	// commands inside a bubblewrap sandbox (Linux only). nil (the key
	// omitted) means enabled, so existing configs load unchanged. Disabling
	// it runs those commands directly on the host with no filesystem,
	// network, or environment isolation from the workflow - see
	// .agents/rules/10-security-privacy.md before turning this off.
	Sandbox *bool `toml:"sandbox"`
}

type HookConfigFile struct {
	// Path is the file these bytes were read from.
	Path string
	// Data is the raw TOML. Parsing happens in internal/hooks; this type owns
	// provenance only.
	Data []byte
	// Project marks the workspace's own config, as opposed to the user's. Every
	// surface that shows a hook shows this, because "which of these came with
	// the repository" is the question a reader actually has.
	Project bool
}

type HooksSource struct {
	// Files are the hook-bearing configs, user config FIRST.
	//
	// Order is load-bearing rather than cosmetic: PreToolUse stops at the first
	// deny, so the user's own gates answer before a repository's do.
	Files []HookConfigFile
	// Warnings are user-visible startup diagnostics - one per config file that
	// declared hooks mivia will not load. A silently ignored hook is how
	// someone concludes hooks are broken.
	Warnings []string
}

type IntegrationsConfig struct {
	Tavily TavilyConfig `toml:"tavily"`
}

type LoadOptions struct {
	ConfigPath string
	// WorkspaceRoot selects the project MCP configuration. Empty uses the
	// current working directory for backward compatibility.
	WorkspaceRoot      string
	ProviderOverride   string
	ModelOverride      string
	AllowMissingConfig bool
	// AutoBootstrapUserConfig silently writes a minimal default config to
	// UserConfigPath() (DefaultUserConfigTOML) when the normal search
	// (opts.ConfigPath, then DefaultConfigCandidates()) finds no config file
	// anywhere. It only fires when opts.ConfigPath was left empty - an
	// explicit --config/$MIVIA_CONFIG miss stays a real error (or, for
	// $MIVIA_CONFIG, falls through to the remaining candidates, unchanged
	// pre-existing behavior) rather than being silently papered over. It
	// does not require AllowMissingConfig to also be set, but callers should
	// normally set both: if HOME cannot be resolved (UserConfigPath() is
	// ""), bootstrap is a no-op and AllowMissingConfig alone then decides
	// whether that is a hard error or a found=false load.
	//
	// Defaults to false (zero value) for every existing caller; wire it to
	// true only where a config-file-writing side effect on a missing config
	// is actually wanted (currently: `mivia chat` only - see
	// internal/clichat/chat_command.go's runChat). Every read-only/internal/
	// test caller of config.Load keeps today's found=false behavior
	// unchanged.
	AutoBootstrapUserConfig bool
}

type LoadedAgentFile struct {
	// Name is the canonical agent name from the filename (without .toml).
	Name   string
	Source AgentSource
	Path   string
	Spec   AgentFileSpec
}

type MCPConfig struct {
	Enabled                 bool              `toml:"enabled"`
	StartupTimeoutSeconds   int               `toml:"startup_timeout_seconds"`
	MaxServers              int               `toml:"max_servers"`
	MaxToolsPerServer       int               `toml:"max_tools_per_server"`
	MaxToolSchemaBytes      int               `toml:"max_tool_schema_bytes"`
	MaxToolDescriptionBytes int               `toml:"max_tool_description_bytes"`
	MaxToolResultBytes      int               `toml:"max_tool_result_bytes"`
	Servers                 []MCPServerConfig `toml:"servers"`
}

type MCPHeaderConfig struct {
	Name     string `toml:"name"`
	ValueEnv string `toml:"value_env"`
}

type MCPServerConfig struct {
	ID             string            `toml:"id"`
	Transport      string            `toml:"transport"`
	Command        string            `toml:"command"`
	URL            string            `toml:"url"`
	Args           []string          `toml:"args"`
	Env            []string          `toml:"env"`
	Headers        []MCPHeaderConfig `toml:"headers"`
	Global         bool              `toml:"global"`
	TimeoutSeconds int               `toml:"timeout_seconds"`
}

type MCPServerSettings struct {
	ID        string
	Transport string
	Command   string
	Args      []string
	Endpoint  string
	EnvNames  []string
}

type MemoryConfig struct {
	// Enabled controls whether the memory tools are wired. nil (the key
	// omitted) means enabled, so existing configs load unchanged.
	Enabled *bool `toml:"enabled"`
	// StoreBackend is "memory" (ephemeral, in-process) or "sqlite"
	// (durable, default). Mirrors [subagents] store_backend.
	StoreBackend string `toml:"store_backend"`
	// StorePath is the project memory database file. Empty resolves by the
	// three-tier rule in resolveMemoryConfig: a workspace with its own
	// project config defaults to <workspace>/.mivia/memory.db; an ad-hoc
	// directory defaults to a temp-dir store keyed by the sanitized root.
	// A repo owner may point it at a tracked path and commit memories with
	// the repository. Relative paths resolve against the workspace root;
	// "~/..." expands to the home directory.
	StorePath string `toml:"store_path"`
	// OrgID is the org identity for org-scoped memory, honored from the
	// user config file only. Empty means org scope is unavailable.
	OrgID string `toml:"org_id"`
	// MaxEntryBytes caps one rendered entry. Default 8192.
	MaxEntryBytes int `toml:"max_entry_bytes"`
	// MaxEntries caps the row count per store file. Default 500.
	MaxEntries int `toml:"max_entries"`
	// MaxSearchResults caps memory_search results. Default 8.
	MaxSearchResults int `toml:"max_search_results"`
	// BlockPatterns are regexes; a save whose content matches any of them is
	// refused. Configuration-only, like the privacy redaction patterns.
	BlockPatterns []string `toml:"block_patterns"`
	// InjectCore enables auto-injecting the bounded "core" memory tier into
	// the system prompt at session start (D1, plan 76). Default false: it
	// changes every session's prompt composition, and round-2 review of
	// plan 76 found operators who allowlist the mivia binary in
	// [tools].run_allowlist weaken D1a's promotion gate - shipping this off
	// by default means an operator opts into that exposure per repo,
	// consciously, rather than getting new prompt content on upgrade.
	InjectCore bool `toml:"inject_core"`
}

type MessagingConfig struct {
	// Enabled is ignored: messaging is always enabled. Retained so older
	// configs with enabled=true|false still parse without error.
	Enabled *bool `toml:"enabled"`
	// MaxBodyBytes is the per-message inline body budget. Default 2048.
	MaxBodyBytes int `toml:"max_body_bytes"`
	// MaxMessagesPerTask is the child upstream send quota per attempt. Default 32.
	MaxMessagesPerTask int `toml:"max_messages_per_task"`
	// MailboxCapacity is parent→child mailbox depth (phase 03). Default 32.
	MailboxCapacity int `toml:"mailbox_capacity"`
	// MaxPendingQuestions is RESERVED and a no-op: the effective value is always
	// 1. Exactly one park per task is structurally enforced by the question
	// registry (one pendingQuestion per runID/taskID key) plus the awaiting_input
	// single-bit ledger status; N>1 is unsupported. The field still parses from
	// TOML (and the config resolver still fills the default of 1) so existing
	// configs load unchanged, but nothing reads it for behavior.
	MaxPendingQuestions int `toml:"max_pending_questions"`
	// SteerWatchdogSeconds: nil = default (300s); explicit 0 = disabled
	// (unbounded); positive = seconds.
	SteerWatchdogSeconds *int `toml:"steer_watchdog_seconds"`
	// Routing is parent-side Ask referral policy (plan 53.04). Always active.
	Routing MessagingRoutingConfig `toml:"routing"`
}

type MessagingRoutingConfig struct {
	// Mode is "policy" (default) or "parent" (unimplemented).
	Mode string `toml:"mode"`
	// MaxAsksPerTask bounds UNANSWERED asks posted by one task. Default 4.
	// Semantics: the slot is released when an ask is answered or sealed.
	MaxAsksPerTask int `toml:"max_asks_per_task"`
	// MaxReferralDepth is max hops in an ask chain (A→B→C = 2). Default 2.
	MaxReferralDepth int `toml:"max_referral_depth"`
	// Allow is "from_role->to_role" pairs. Empty = any live same-run role;
	// referral-as-spawn always requires an explicit pair.
	Allow []string `toml:"allow"`
	// MaxReferralSpawnsPerRun caps referral-as-spawn. Default 4.
	MaxReferralSpawnsPerRun int `toml:"max_referral_spawns_per_run"`
}

type ModelSettings struct {
	Name                string
	ContextWindowTokens int
	MaxOutputTokens     int
	Reasoning           string
	ReasoningEfforts    []string
}

type ModelSpec struct {
	Name                string `toml:"name"`
	ContextWindowTokens int    `toml:"context_window_tokens"`
	MaxOutputTokens     int    `toml:"max_output_tokens,omitempty"`
	// ReasoningEfforts is the ordered set of reasoning levels this model
	// offers. Empty means the model has no reasoning surface. Order is
	// preserved because it is the order the /effort picker lists.
	ReasoningEfforts []reasoning.Level `toml:"reasoning_efforts,omitempty"`
	// Reasoning is this model's DEFAULT effort and must be a member of
	// ReasoningEfforts. Empty means the model ships with no reasoning field
	// sent, which a model that offers efforts may still choose - the user
	// opts in through /effort. Reasoning belongs to the model rather than to
	// [chat] because capabilities and value sets differ per model, so one
	// session-global value would be wrong for every model it did not match.
	Reasoning reasoning.Level `toml:"reasoning,omitempty"`
	// ReasoningDialect is this model's wire shape. Empty uses the provider's
	// vetted default where one exists; load refuses an active level with no
	// resolvable dialect rather than letting the key silently do nothing.
	ReasoningDialect reasoning.Dialect `toml:"reasoning_dialect,omitempty"`
}

type PrivacyConfig struct {
	RedactToolArgs bool `toml:"redact_tool_args"`
	// RedactionPatterns are regexes applied to operator-visible text (tool
	// previews, event bodies, audit metadata). Nothing is compiled in: unset
	// means no text is redacted anywhere. An invalid pattern is a load error.
	RedactionPatterns []string `toml:"redaction_patterns"`
	// RedactionKeyNames are JSON object keys whose values are elided wholesale
	// (case-insensitive substring match). Unset means no key-based redaction.
	RedactionKeyNames []string `toml:"redaction_key_names"`
	// RedactionPlaceholder replaces each match. Defaults to "[redacted]".
	RedactionPlaceholder string `toml:"redaction_placeholder"`
}

type ProjectSettings struct {
	EnvFile         string
	BranchPrefix    string
	SystemPrompt    string
	Temperature     string
	MaxTokens       string
	MaxPromptTokens string
	MaxSteps        string
	RunTimeoutSec   int
	StoreBackend    string
	StorePath       string
	Sandbox         bool
	RedactToolArgs  bool
}

type ProviderConfig struct {
	// Models is the explicit, finite model catalog for this provider.
	Models []ModelSpec `toml:"models,omitempty"`
	// DefaultModel is this provider's default model. When Models is non-empty,
	// it must be a member of the allowlist.
	DefaultModel string `toml:"default_model,omitempty"`
	// LegacyModel is a decode sentinel. The old scalar provider model key is
	// rejected explicitly so it cannot override an explicit catalog entry.
	LegacyModel *string `toml:"model"`
	BaseURL     string  `toml:"base_url"`
	APIKeyEnv   string  `toml:"api_key_env"`
	HTTPReferer string  `toml:"http_referer"`
	XTitle      string  `toml:"x_title"`
}

type ProviderModelGroup struct {
	Provider       string
	DefaultModel   string
	Models         []ModelSpec
	Active         bool
	Selectable     bool
	DisabledReason string
}

type ProviderRuntime struct {
	ProviderName string
	BaseURL      string
	APIKeyEnv    string
	APIKeySet    bool
	APIKey       string
	HTTPReferer  string
	XTitle       string
	Models       []ModelSpec
}

type ProviderSection struct {
	Name string `toml:"name"`
	// PromptCache is "auto" (default) or "off". "auto" enables capture of
	// provider-reported prompt-cache usage accounting and, on providers that
	// honor explicit markers (openrouter), emission of cache_control markers
	// on the stable prefix. "off" disables both. It cannot disable a
	// provider's own automatic server-side caching.
	PromptCache string `toml:"prompt_cache"`
	// StreamIdleTimeoutSeconds bounds the gap between successive bytes on any
	// provider read (streaming or non-streaming), once the first byte has
	// arrived. Unset (nil) resolves to DefaultStreamIdleTimeoutSeconds
	// (100s). This is a process-wide setting, not per-provider: mivia runs
	// one active provider configuration per process.
	StreamIdleTimeoutSeconds *int `toml:"stream_idle_timeout_seconds"`
	// StreamFirstByteTimeoutSeconds bounds the wait for the first byte of a
	// provider read, from request-issued. Unset (nil) resolves to
	// DefaultStreamFirstByteTimeoutSeconds (240s).
	StreamFirstByteTimeoutSeconds *int `toml:"stream_first_byte_timeout_seconds"`
}

type ProviderSettings struct {
	Name         string
	BaseURL      string
	APIKeyEnv    string
	DefaultModel string
	Models       []ModelSettings
}

type Resolved struct {
	// RedactionPolicy is compiled during Load so an invalid pattern fails at
	// startup. Nil means the workspace configured none, which redacts nothing.
	RedactionPolicy *redact.Policy
	// MaxSteps is nil when unconfigured, so the chat default applies. A
	// configured 0 is meaningful (unlimited) and must not be confused with it.
	MaxSteps     *int
	ConfigPath   string
	EnvFilePath  string
	EnvFileUsed  bool
	ProviderName string
	Model        string
	// Models is retained as a compatibility projection of ModelProfiles.
	Models []string
	// ModelProfiles is the active provider's copied model catalog.
	ModelProfiles []ModelSpec
	// ProviderRuntimes contains resolved backend material for provider.NewForProvider.
	ProviderRuntimes map[string]ProviderRuntime

	BaseURL   string
	APIKeyEnv string
	APIKeySet bool
	// APIKey is populated only for runtime use; never print it.
	APIKey          string
	HTTPReferer     string
	XTitle          string
	SystemPrompt    string
	MaxPromptTokens *int
	// MaxContextTokens is retained as a compatibility projection of the
	// selected model's effective prompt budget.
	MaxContextTokens       int
	Temperature            *float64
	MaxTokens              *int
	ShowIterationNotices   bool
	ShowPromptCacheNotices bool
	Subagents              SubagentConfig
	Worktrees              WorktreeConfig
	StoreBackend           string
	StorePath              string
	// StorePathSet reports whether [subagents].store_path was set in the
	// selected configuration. It lets repository storage resolve its default
	// from the repository root instead of the current worktree.
	StorePathSet bool
	// Privacy is resolved from [privacy] TOML and MIVIA_REDACT_TOOL_ARGS.
	Privacy PrivacyConfig
	// Context is the operator's durable storage ceilings, uncapped by default.
	Context ContextConfig
	// Tools is the resolved tool execution policy.
	Tools ToolsConfig
	// MCP is the resolved MCP server configuration.
	MCP MCPConfig
	// MCPWarnings are scrubbed operator diagnostics for the MCP configuration.
	MCPWarnings []string
	// Memory is the resolved [memory] configuration.
	Memory MemoryConfig
	// Harness is the resolved [harness] configuration.
	Harness HarnessConfig
	// Approvals is the resolved [approvals] configuration.
	Approvals ApprovalsConfig
	// TUI is the resolved [tui] configuration.
	TUI TUIConfig
	// Workflows is the resolved [workflows] configuration.
	Workflows WorkflowsConfig
	// Verifiers is the workspace-declared verifier profile set from the
	// [verifiers.<name>] tables. The host ships no built-in profiles.
	Verifiers map[string]VerifierProfile

	// TavilyAPIKey is the Tavily web search API key (set via TAVILY_API_KEY env).
	// When set, the search tool uses Tavily as the primary web search engine.
	TavilyAPIKey string
	// StreamIdleTimeout is the resolved [provider] stream_idle_timeout_seconds,
	// defaulted when unset. See ProviderSection.StreamIdleTimeoutSeconds.
	StreamIdleTimeout time.Duration
	// StreamFirstByteTimeout is the resolved [provider]
	// stream_first_byte_timeout_seconds, defaulted when unset. See
	// ProviderSection.StreamFirstByteTimeoutSeconds.
	StreamFirstByteTimeout time.Duration

	// PromptCache is the resolved "auto" or "off" policy for prompt-cache
	// usage capture and explicit cache_control markers. Always one of those
	// two values after Load - see ProviderSection.PromptCache.
	PromptCache string
	// contains filtered or unexported fields
}

type SubagentConfig struct {
	MaxWorkers int `toml:"max_workers"`
	// MaxDepth caps the dependency depth of one orchestrated task graph
	// (spawn_agent depends_on chains). 0 means unlimited (default); a
	// positive value caps the depth.
	MaxDepth int `toml:"max_depth"`
	// MaxFanout caps the number of tasks admitted in one orchestration.
	// 0 means unlimited (default); a positive value caps the count.
	MaxFanout      int `toml:"max_fanout"`
	DefaultTimeout int `toml:"default_timeout_seconds"`
	// DefaultRequestTimeoutSec is the per-LLM-request timeout for subagents
	// (seconds). When 0, requestTimeout() uses DefaultSubagentRequestTimeoutSec
	// (1800s, 30 minutes) as the per-request context deadline. The 15-minute
	// http.Client wall stays the hard per-attempt bound; the 12-hour
	// orchestration default no longer feeds individual subagent requests.
	DefaultRequestTimeoutSec int `toml:"default_request_timeout_seconds"`
	// DefaultTotalTimeoutSec is the whole-subagent wall-clock budget
	// (seconds). 0 = unset = DefaultSubagentTotalTimeoutSec (3600s, 60
	// minutes). Negative = off: a direct spawn with no per-task timeout then
	// has no handler-level bound at all, and workflow or panel steps whose
	// own timeout is unset stay bounded only by workflow policy - this is an
	// explicit operator opt-out of the last-resort termination guarantee. A
	// positive value is the budget itself; a tighter per-task timeout from
	// the caller still wins.
	DefaultTotalTimeoutSec int `toml:"default_total_timeout_seconds"`
	// WireStream opts nested subagent calls into the wire-stream transport:
	// the request goes to the provider with stream:true while the call keeps
	// its non-stream contract - the full answer is assembled before it comes
	// back. Nil means unset, which resolves to true - the pointer exists so
	// an explicit `wire_stream = false` is distinguishable from an absent
	// key, which a plain bool cannot express. False opts out and keeps every
	// nested call on the plain non-stream endpoint. See WireStreamResolved
	// for why this default was briefly flipped off and then restored.
	WireStream    *bool  `toml:"wire_stream"`
	DefaultBudget int    `toml:"default_budget"`
	SystemPrompt  string `toml:"system_prompt"`
	NestedSteps   int    `toml:"nested_steps"`

	// StoreBackend selects the ledger storage backend: "memory" (default) or "sqlite".
	StoreBackend string `toml:"store_backend"`

	// StorePath is the configured SQLite file path. Chat uses this path for
	// sessions, context, worktree routes, and orchestration.
	StorePath string `toml:"store_path"`

	// HandleRetentionSeconds controls how long completed orchestration run
	// handles remain accessible via inspect_agents/join_run/cancel_run
	// before automatic eviction. Default: 600 (10 minutes). 0 = no retention.
	HandleRetentionSeconds int `toml:"handle_retention_seconds"`

	// MaxAuditRounds controls the maximum number of ADLC Step 5 bug audit
	// rounds. When 0 (default), rounds are unlimited. Set to a positive
	// value to cap.
	MaxAuditRounds int `toml:"max_audit_rounds"`

	// InlineOutputBytes is the per-task output size threshold (bytes). Task
	// results whose output body is at or below this threshold are inlined in
	// the model-visible result envelope (the "output" field). Results above
	// this threshold emit only "output_ref", "output_bytes", and a bounded
	// "synopsis"; the parent fetches the full body via ledger_read.
	// Default: 4096. An explicit 0 means "always use refs" (never inline) and
	// is preserved through resolution via inlineOutputBytesSet; an absent key
	// falls back to the 4096 default. Errors follow the same rule with
	// "error"/"error_ref".
	InlineOutputBytes int `toml:"inline_output_bytes"`

	// SchemaRetryMax is how many corrective re-entries a multi-step child may
	// take after an invalid schema-validated reply (plan tools/02). Default 2.
	// The initial attempt is separate: retry_max=2 allows two corrective turns.
	// Clamped at load: <= 0 means the default 2; a positive value above
	// MaxSchemaRetryMax is clamped to it.
	SchemaRetryMax int `toml:"schema_retry_max"`

	// SpawnStaggerMs staggers the start of each task after the first within
	// one dispatch batch by this many milliseconds, so concurrent workers do
	// not fire their first provider call on the same instant (the step-1
	// thundering-herd hang behind overloaded local proxies). Default: 150.
	// An explicit 0 disables staggering and is preserved through resolution
	// via spawnStaggerMsSet, mirroring inline_output_bytes; an absent key
	// falls back to the default. Values above 1000 are clamped to 1000.
	SpawnStaggerMs int `toml:"spawn_stagger_ms"`

	// Messaging configures typed agent-to-agent messaging (plan 53). Nested
	// under [subagents.messaging]. Always enabled (product decision 2026-08-03).
	Messaging MessagingConfig `toml:"messaging"`

	// TaskRetry configures automatic retry/backoff for a dispatched task whose
	// failure is classified transient (provider.IsTransient - network blip,
	// 429, 5xx, timeout) or that timed out. Nested under [subagents.retry].
	// Distinct from SchemaRetryMax above, which governs corrective re-entries
	// after an invalid schema-validated reply within one task, not whole-task
	// retry. All-zero (the default) disables retry entirely, identical to
	// today's behavior: a deployment must opt in. See task_retry_config.go
	// for the TaskRetryConfig type.
	TaskRetry TaskRetryConfig `toml:"retry"`
	// contains filtered or unexported fields
}

type TUIConfig struct {
	Theme string `toml:"theme"`
	// Mouse is the cockpit's mouse-capture default: true (default)
	// enables in-app drag-select, copy, and wheel; false hands the mouse
	// to the terminal for native selection. MIVIA_MOUSE overrides it at
	// startup; Settings → General changes it live. See
	// docs/design/cockpit-research.md rule 6.5.
	Mouse         *bool `toml:"mouse"`
	ShowReasoning *bool `toml:"show_reasoning"`
	ScrollLines   *int  `toml:"scroll_lines"`
	ScreenReader  *bool `toml:"screen_reader"`
	ReducedMotion *bool `toml:"reduced_motion"`
}

type TaskRetryConfig struct {
	// MaxRetries is the maximum retry attempts per task. 0 (default) disables
	// retry.
	MaxRetries int `toml:"max_retries"`
	// BaseBackoffSeconds is the initial backoff before the first retry.
	BaseBackoffSeconds float64 `toml:"base_backoff_seconds"`
	// MaxBackoffSeconds caps the per-retry backoff.
	MaxBackoffSeconds float64 `toml:"max_backoff_seconds"`
	// BackoffFactor is the exponential multiplier applied after each attempt.
	// 0 selects the coordinator's default (2.0) once MaxRetries > 0.
	BackoffFactor float64 `toml:"backoff_factor"`
	// JitterFraction randomizes each backoff by ±JitterFraction/2. 0 disables
	// jitter.
	JitterFraction float64 `toml:"jitter_fraction"`
}

type TavilyConfig struct {
	// APIKeyEnv overrides the env var name (default "TAVILY_API_KEY").
	APIKeyEnv string `toml:"api_key_env"`
	// Disable explicitly disables Tavily even if the env var is set.
	Disable bool `toml:"disable"`
}

type ToolsConfig struct {
	// RunAllowlist extends the built-in default allowlist (union).
	RunAllowlist []string `toml:"run_allowlist"`
	// RunAllowlistOnly replaces the built-in default allowlist entirely.
	RunAllowlistOnly []string `toml:"run_allowlist_only"`
	// RunBlocklist removes programs from the resolved allowlist (takes precedence).
	RunBlocklist []string `toml:"run_blocklist"`
	// DisableTools removes built-in tools by name.
	DisableTools []string `toml:"disable_tools"`
	// EnvAllowlist extends the built-in default env var allowlist (union).
	// Entries ending in "*" are treated as prefix rules (e.g. "GIT_*" allows all GIT_ vars).
	EnvAllowlist []string `toml:"env_allowlist"`
	// EnvAllowlistOnly replaces the built-in default env var allowlist entirely.
	// Entries ending in "*" are treated as prefix rules (e.g. "GIT_*" allows all GIT_ vars).
	EnvAllowlistOnly []string `toml:"env_allowlist_only"`
	// EnvBlocklist removes vars from the resolved env allowlist (takes precedence).
	// Entries ending in "*" are treated as prefix rules (e.g. "GIT_*" blocks all GIT_ vars).
	EnvBlocklist []string `toml:"env_blocklist"`
	// EnvAllowKeywordBlocklist drops variables whose name contains any of these
	// substrings even when a prefix rule admitted them. Exact-name entries in
	// EnvAllowlist are unaffected, so a build needing one names it explicitly.
	EnvAllowKeywordBlocklist []string `toml:"env_allow_keyword_blocklist"`
	// RunTimeoutSec is the default timeout for run_command (seconds).
	RunTimeoutSec int `toml:"run_timeout_seconds"`
	// ToolRunTimeoutSec is the registry-wide default run timeout (seconds)
	// the SDK tool-registry backstop applies to tools that declare no
	// Capability.Timeout. Positive = that bound. 0 (default) or negative =
	// no registry-wide cap (the agent layer maps it to the SDK's
	// TimeoutNone). Uncapped is the correct default: the CLI's own
	// dispatcher already arms every tool call's Capability.Timeout (or the
	// [subagents] default_timeout_seconds fallback) as a real context
	// deadline, so the SDK backstop is a second, redundant enforcement
	// layer that must never be tighter than the CLI's declared budgets
	// unless the operator explicitly asks for it. Without this mapping the
	// SDK's hardcoded 10-minute default silently killed long-budget tools
	// (dispatch_tasks' 12h orchestration window).
	ToolRunTimeoutSec int `toml:"tool_run_timeout_seconds"`
	// MaxReadBytes caps read_file output (bytes).
	MaxReadBytes int `toml:"max_read_bytes"`
	// MaxEditFileBytes caps the file size editable in place by search_replace and multi_edit (bytes).
	// 0 means uncapped today; expected to become an explicit opt-out once the derived budget profile ships.
	MaxEditFileBytes int `toml:"max_edit_file_bytes"`
	// MaxWriteKB caps write_file content (KiB).
	MaxWriteKB int `toml:"max_write_kb"`
	// MaxOutputBytes caps run_command output (bytes).
	MaxOutputBytes int `toml:"max_output_bytes"`
	// MaxListDirEntries caps list_dir output.
	MaxListDirEntries int `toml:"max_list_dir_entries"`
	// MaxToolResultBytes caps each tool result stored in agent-loop history
	// (bytes), applied identically to the interactive session loop and nested
	// sub-agent loops. 0 (the default) means uncapped: per-tool budgets are
	// the bound. Positive values below 1024 are rejected at load.
	MaxToolResultBytes int `toml:"max_tool_result_bytes"`
	// BatchResultBudgetBytes bounds what ONE tool batch may add to history,
	// across all of its parallel calls together. max_tool_result_bytes bounds
	// each call in isolation and cannot see the others, so N calls that are
	// each honestly under it still blow the context when they land in the same
	// step; this is the only bound that sees the batch as a whole.
	//
	// nil (absent) resolves to the derived budget; explicit 0 disables it;
	// any negative derives it from the model's prompt budget (a quarter of
	// it, floor 256 KiB; inert when there is no prompt budget). A positive
	// value is the literal byte budget and must be at least 16 KiB - below
	// that every batch would degrade to references.
	//
	// Over-budget results are degraded to content references, never failed:
	// the model already paid for the calls and their side effects already
	// happened.
	BatchResultBudgetBytes *int `toml:"batch_result_budget_bytes"`
	// RefOnlyTools is an opt-in list of tool names whose results are always
	// spooled and replaced by a ref-only notice, never inlined whole; empty
	// = off.
	RefOnlyTools []string `toml:"ref_only_tools"`
	// MaxTavilyResponseBytes bounds the bytes read from a Tavily API response
	// body - the `search` tool's Tavily path and `extract`. It is NOT a
	// truncation cap: the tools never cut content. The bound exists so their
	// maximum output is a finite, declarable number, which the dispatcher's
	// output backstop is derived from; a response over the bound is refused
	// with an explicit error naming this key. 0 or negative resolves to the
	// built-in default (never "unlimited" - an unlimited response could not be
	// declared, and undeclared output is what the backstop destroys). Values
	// outside [1024, 64 MiB] are rejected at load.
	MaxTavilyResponseBytes int `toml:"max_tavily_response_bytes"`
	// MaxFetchKB bounds the body read by fetch_url (KiB). Default 4096 (4 MiB).
	// 0 means unlimited. Unlimited is safe for fetch_url because it truncates
	// an over-bound body instead of refusing it - unlike the Tavily bound, an
	// unbounded read still yields a bounded, usable result, so nothing the
	// dispatcher derives from a declared budget depends on this number.
	MaxFetchKB int `toml:"max_fetch_kb"`
	// MemoryBackstopMB is the OOM guard (MiB) for tools that may load whole
	// files into memory when volume caps are uncapped (read/edit/list budgets).
	// Shipped default 256. This is NOT a context-cost cap. 0 or negative
	// resolves to the default so the guard cannot be accidentally disabled.
	MemoryBackstopMB int `toml:"memory_backstop_mb"`
	// RedactToolArgs hides argv from operator-visible output.
	RedactToolArgs bool `toml:"redact_tool_args"`
	// SecretPathPatterns replaces the hard-coded secret path blocklist.
	SecretPathPatterns []string `toml:"secret_path_patterns,omitempty"`
	// SecretPathExceptions adds exceptions to the secret path blocklist.
	SecretPathExceptions []string `toml:"secret_path_exceptions,omitempty"`
	// Core is the always-advertised tool tier (plan tools/05). nil (the key
	// omitted) keeps every authorized tool core, which is byte-identical to the
	// behavior before deferred loading existed. When set, tools outside it are
	// deferred: their schemas are advertised (plan tools-advertising/01) but
	// locked for execution until the model loads them with load_tools.
	// Naming a tool here never grants authority - the list is intersected
	// with the agent's effective tool set.
	Core *[]string `toml:"core,omitempty"`
	// SearchIgnorePatterns adds directory/file names to skip during grep/glob walks.
	// Extends the built-in defaults (.git, node_modules, vendor). Does not replace them.
	SearchIgnorePatterns []string `toml:"search_ignore_patterns,omitempty"`
	// WritePathBlocklist names workspace-relative paths or directories whose
	// write tools refuse to change. There is no compiled-in default
	// (DefaultWritePathBlocklist is empty); protection is opt-in. Removal of
	// an entry named here is via WritePathBlocklistRemove. Entries use
	// forward slashes and are normalized
	// (trimmed, cleaned) at load; an entry that is empty, ".", or absolute is
	// a load error.
	// The blocklist applies to workflow agent steps, whose write tools
	// (write_file, search_replace, multi_edit, delete_file) refuse listed
	// paths. The interactive session registry does not enforce it.
	WritePathBlocklist []string `toml:"write_path_blocklist,omitempty"`
	// WritePathBlocklistRemove removes workspace-relative paths or directories
	// from the effective write-path blocklist (the built-in defaults plus
	// WritePathBlocklist) for workflow agent steps. It is the explicit opt-out
	// for a default entry (.git, .mivia/mivia.toml) or a project addition, and
	// it is the only way to unblock those two defaults. Unblocking a path is a
	// trust decision: .mivia/mivia.toml carries this very blocklist, so an
	// agent that can edit it can remove its own restrictions (including
	// .mivia/agents, .mivia/policy, .mivia/workflows, go.mod, go.sum, and
	// go.work), and .git carries commit
	// history and hooks, so an agent that can edit it can rewrite history or
	// plant hooks that bypass the host hook-policy gates. Keep the defaults
	// blocked unless a host-owned step genuinely needs the path. Entries use
	// the same normalization and validation rules as WritePathBlocklist; an
	// entry listed in BOTH keys is a load error (the keys contradict).
	WritePathBlocklistRemove []string `toml:"write_path_blocklist_remove,omitempty"`
	// MaxInspectRepositoryBytes caps the inspect_repository result envelope
	// (bytes). Unlike MaxReadBytes/MaxOutputBytes there is no uncapped state:
	// the tool's output must always be valid, bounded JSON. 0 or negative
	// resolves to the built-in 64 KiB default. Values outside
	// [MinInspectRepositoryBytes, MaxInspectRepositoryBytes] are rejected at load.
	MaxInspectRepositoryBytes int `toml:"max_inspect_repository_bytes"`
	// DiagnosticsCommand is the DEPRECATED alias for the reserved "default"
	// entry of DiagnosticsCommands. It is the argv of the project diagnostics
	// command the get_diagnostics tool runs. resolveToolsConfig folds a set
	// alias into DiagnosticsCommands["default"] and then clears it, so
	// Validate (and every consumer) sees exactly one surface; setting BOTH
	// the alias and the map is ambiguous and rejected at load. Empty (unset
	// or []) means the tool is not registered. When set, argv[0] must be a
	// bare program name on the resolved run allowlist (run_allowlist_only
	// when set, else run_allowlist); validation rejects anything else at
	// load, mirroring the run_command gate, so a diagnostics tool that could
	// never register cannot load clean.
	DiagnosticsCommand []string `toml:"diagnostics_command"`
	// DiagnosticsCommands maps a command name to the argv of a project
	// diagnostics command the get_diagnostics tool runs. Empty or unset means
	// the tool is not registered; "default" is the reserved name for the
	// deprecated diagnostics_command alias (declaring it explicitly is
	// allowed). Every entry is validated at load like the run_command gate:
	// non-empty argv, argv[0] a bare program name on the EFFECTIVE run
	// allowlist (run_allowlist_only when set, else run_allowlist, minus
	// run_blocklist - the tools layer subtracts the blocklist in
	// configuredRunAllowlist, so a command that could never register is a
	// load error). Command names must be non-empty, non-whitespace, and
	// unique after case folding.
	DiagnosticsCommands map[string][]string `toml:"diagnostics_commands"`
}

type VerifierCommand struct {
	Check   string
	Program string
	Args    []string
}

type VerifierProfile struct {
	// GoModuleBaseline marks a profile whose commands read Go module files.
	// When any referenced profile sets it, admission captures go.mod/go.sum
	// and the sandbox pins them so a workflow agent cannot change what the
	// gate builds against.
	GoModuleBaseline bool
	Commands         []VerifierCommand
}

type WorkflowPanelLimits struct {
	MemberMaxOutputPerCall    *int `toml:"member_max_output_per_call"`
	MemberMaxToolCalls        *int `toml:"member_max_tool_calls"`
	SynthesisMaxOutputPerCall *int `toml:"synthesis_max_output_per_call"`
	SynthesisMaxToolCalls     *int `toml:"synthesis_max_tool_calls"`
	// MemberDeadlineDefaultSeconds overrides the wall-clock default a
	// panel member attempt gets when the workflow declares no run
	// deadline (max_duration_seconds = 0). Seconds, matching
	// definition.Limits.MaxDurationSeconds' unit.
	MemberDeadlineDefaultSeconds *int `toml:"member_deadline_default_seconds"`
}

type WorkflowsConfig struct {
	Panels WorkflowPanelLimits `toml:"panels"`
}

type WorktreeConfig struct {
	// BranchPrefix is the prefix for branches that mivia creates for worktrees.
	BranchPrefix string `toml:"branch_prefix"`
}