agentruntime

type Builder struct{}

type Runtime struct {
	Session *session.Session
	Fresh   bool

	Cfg      agent.LoopConfig
	Registry *agent.Registry

	Permissions   *permissions.Permissions
	AgentTool     *agent.AgentTool
	SubagentTasks *subagents.Registry
	MCPManager    *mcppkg.Manager

	Skills    []skills.Skill
	SkillTool *agent.SkillTool

	LSPManager      *lsp.Manager
	CodeMapProvider codemap.Provider

	Adapter        adapter.Client
	RouterAdapters *cli.RouterAdapters

	// ChatOptions is the live, as-constructed options snapshot Adapter
	// (and RouterAdapters) were built from — mirrors internal/tui's own
	// m.opts. Build seeds it (including any advisor-model override
	// applied to spec.ChatOptions.Model below); RebuildAdapterForEffort
	// mutates ChatOptions.ReasoningEffort and reconstructs every adapter
	// that bakes reasoning effort in at construction time. Session-only —
	// never written back to config.toml.
	ChatOptions cli.ChatOptions

	// RoutingAuto is the session-live mirror of fileCfg.Router.RoutingAuto()
	// at construction, ANDed with the pair having actually resolved —
	// whether subagent dispatch/summarization currently route through
	// RouterAdapters' implementer/advisor pair. A persisted mode="auto"
	// whose pair failed to resolve (see Build's warning) reports false
	// here rather than claiming a toggle that silently does nothing.
	// Distinct from FileCfg.Router.Mode (the on-disk setting Build read
	// once): this field is what SetAdvisorRouting toggles, session-only,
	// matching internal/tui/cmd_router.go's own
	// m.routerMode/RouterModeAuto split between "what's persisted" and
	// "what's live."
	RoutingAuto bool

	// GHClient is the typed GitHub client backing the pr_*/issue_*/
	// git_push composite tools (see Build). Lazy and side-effect-free
	// to construct — the real auth/network cost is paid on first tool
	// call, not here — so every caller gets it unconditionally, same as
	// MCPManager. Exposed on Runtime because TUI's status bar also
	// reads it directly (resolveCurrentPRCmd) for a display-only
	// current-PR lookup that has no ACP equivalent.
	GHClient githubapi.Interface

	// RecallIndex backs the model-callable session_recall tool (see
	// Build) — a full-text/semantic index over every saved session at
	// ~/.yottacode/index.sqlite, shared across every caller (it's one
	// file on disk, not per-session state; SQLite's WAL mode is what
	// makes concurrent handles from oneshot/tui/acp safe at once). Nil
	// when recall.Open fails (non-fatal — see rt.Warnings); callers
	// must Close it themselves when the session ends (TUI's own
	// teardown does this already; CloseSession/Shutdown do it for ACP).
	// Backfilling the corpus (session.List + re-index) stays a
	// TUI-only background job — see internal/tui/run.go — since it's a
	// startup-time catch-up most valuable for the interactive,
	// long-running case; oneshot/ACP sessions still search whatever a
	// prior TUI/backfill run already indexed, they just don't trigger
	// a fresh corpus-wide catch-up themselves.
	RecallIndex *recall.Index

	// Model is the effective model name after Build's own resolution —
	// specifically, when advisor routing is enabled and overrides the
	// requested model, this is the *overridden* name. spec.Model (i.e.
	// spec.ChatOptions.Model) stays whatever the caller originally
	// passed in; callers that display or persist the active model (the
	// TUI's status bar, session bookkeeping) must read this field, not
	// spec.Model, or they'll show a stale name under routing.
	Model string

	PlanMode    *agent.PlanModeState
	AutoMode    *agent.AutoModeState
	YoloMode    *agent.YoloModeState
	LoopControl *agent.LoopControlState

	PlanStore *agent.PlanStore
	CwdRef    *agent.CwdRef

	// CmdSandbox is the optional session-scoped command sandbox backing
	// run_bash and worktree/dispatch sandbox inheritance. Nil preserves
	// HostSandbox behavior.
	CmdSandbox agent.Sandbox

	// SandboxManager owns lazy per-profile containers when sandboxing is enabled.
	SandboxManager *SandboxManager

	FileCfg         config.Config
	ExperimentalSet *experimental.Set
	Mem             memory.Loaded
	EmbedClient     *memory.EmbedClient

	// BaseSystemPrompt is the pre-memory composed prompt (profile framing
	// + skills section, before memory injection). Callers that know the
	// live user prompt at construction time (oneshot) can re-score memory
	// against it and overwrite the session's system message via
	// RecomposeSystemPrompt; callers that don't (TUI, ACP — the prompt
	// arrives later, via session/prompt) just keep what Build already
	// injected with the prompt-unaware memory.SystemPrompt.
	BaseSystemPrompt string

	// RawSystemPrompt is the base system prompt *before*
	// composeSystemPrompt/appendSkillsSection are applied — opts.
	// SystemPrompt (or defaultSystemPrompt) plus the dispatch addendum,
	// nothing else. TUI needs this raw form, not BaseSystemPrompt: its
	// own per-turn/reload paths (rebuildSystemPromptForTurn,
	// reloadMemoryNow, recomposeSystemPromptWithSkills) call
	// composeSystemPrompt/appendSkillsSection themselves, so handing them
	// the already-composed BaseSystemPrompt would double the profile
	// framing and skills section on every turn.
	RawSystemPrompt string

	// Warnings collects non-fatal construction issues (router degrade,
	// embedding model unreachable, MCP server start failures, unknown
	// experimental flags, skills/subagents load warnings) as pre-formatted
	// lines. The caller decides how to surface them — TUI startup
	// notices, oneshot stderr, an ACP diagnostic message.
	Warnings []string
}

type SandboxConfigReloader func() (config.Config, error)

type SandboxConstructor func(ctx context.Context, cfg config.SandboxConfig, id, mountRoot string) (agent.Sandbox, error)

type SandboxHandler struct {
	// contains filtered or unexported fields
}

type SandboxManager struct {
	// contains filtered or unexported fields
}

type SessionSpec struct {
	cli.ChatOptions

	// Cwd is the session's working directory. ChatOptions carries no cwd
	// field — oneshot/tui both derive it from os.Getwd() today. ACP must
	// derive it from session/new's cwd parameter instead, and Build must
	// never call os.Getwd()/os.Chdir() itself: it hosts N concurrent
	// sessions with potentially different cwds in one process.
	Cwd string

	// MCPServers is session-scoped and additive on top of the global
	// fileCfg.MCPServers Build loads from config.toml. Empty for
	// oneshot/tui (they only ever use the global set); ACP's session/new
	// carries this from the client's mcpServers param. On name collision
	// a session-scoped entry overrides the global one of the same name.
	MCPServers []config.MCPServer

	// DisableWorktreeTools excludes EnterWorktreeTool/ExitWorktreeTool
	// from the registry. Both tools call process-global os.Chdir() in
	// addition to updating the session's CwdRef (see
	// EnterWorktreeTool.swapCwd) — safe when one process hosts one
	// session at a time (oneshot, TUI), unsafe when one process hosts N
	// concurrent sessions with different cwds (ACP). oneshot/tui pass
	// false; acp passes true.
	DisableWorktreeTools bool

	// SupportsBackgroundDispatch controls AgentTool.AllowBackground and
	// DispatchTool.SupportsBackground. oneshot passes false (no
	// long-lived session to host async completions — its own rationale,
	// documented at the oneshot call site historically). tui and acp
	// both pass true: both are long-lived processes that can host
	// detached background work and surface its completion later.
	SupportsBackgroundDispatch bool

	// PreCompact is the optional pre-compaction snapshot hook threaded
	// into LoopConfig.Compaction.PreCompact. tui supplies its snapshot
	// writer (writePreSummarySnapshot); oneshot and acp leave this nil,
	// which agent.CompactionConfig treats as "no snapshot taken."
	PreCompact func(history []adapter.Message) (string, error)

	// DeferMCPStart skips starting the MCP manager and registering its
	// tools inside Build. Build still constructs Runtime.MCPManager (via
	// mcp.NewManager) so the caller has something to Start() later — it
	// just doesn't block Build on it. TUI sets this: it deliberately
	// starts MCP servers asynchronously via its own Bubbletea tea.Cmd
	// (internal/tui/cmd_mcp.go) so slow/hanging npx-based servers don't
	// delay first paint, and that existing machinery already knows how
	// to Start() the manager and register tools once it has a
	// *mcp.Manager and *agent.Registry to work with — nothing new is
	// needed there. oneshot and acp both leave this false: neither has a
	// progressive-UI concept, so Build's synchronous start-and-register
	// is exactly what they want (acp's session/new must return only
	// once the session is actually ready).
	DeferMCPStart bool

	// SupportsLiveRouterToggle controls whether Build attempts
	// cli.BuildRouterAdapters even when [router].mode is "off". TUI and
	// ACP are long-lived and let a user flip routing on mid-session
	// (/advisor on, or ACP's "Advisor routing" session config option) —
	// both need the advisor/implementer pair pre-resolved at startup so
	// that toggle can work instantly and so the pair's mere presence can
	// be checked (see internal/tui/cmd_router.go's routerOn and
	// internal/acp/config_options.go's sessionConfigOptions). oneshot has
	// no such toggle — a single `yottacode run` never flips [router].mode
	// mid-session — so it leaves this false: with routing off, Build
	// skips resolving the pair entirely rather than surfacing a stale or
	// misconfigured advisor pair's resolution error as a confusing
	// warning for a session that would never use it anyway.
	SupportsLiveRouterToggle bool
}