@ordewell/core 0.10.4 → 0.10.6

package/dist/index.d.ts

@@ -1,13 +1,11 @@
-import { af as Task, E as ExecutionActor, r as IsolationMergeResult, f as ExecutionRecord, g as GuardTrip, ae as SupervisorLevel, e as ExecutionCommandName, G as GuardTarget, a2 as RunnerId, d as DiscoveredModel, Z as ResearchProgress, Y as ResearchLogEntry, C as ConversationMessage, a7 as SkillInfo, a8 as SkillLoad, ac as SkillsService, L as LegacyPlanState, N as PlanStatus, n as IsolationLandedTask, I as IWorktreeIsolation, F as IsolationTaskStatus, J as PlanIsolation, ar as UsageRecord, a0 as ResearchToolType, Q as PlannerUsage, an as TaskSnapshot, K as PlanState, H as IsolationView, at as Verdict, am as TaskSkillSnapshot } from './Task-DZs9eKgg.js';
-export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, D as DEFAULT_RUNNERS, c as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as IntegrationDisposal, i as InvalidSkill, j as IsolationAvailability, k as IsolationHandoff, l as IsolationHandoffRepo, m as IsolationInactiveReason, o as IsolationLanding, p as IsolationMergeBlock, q as IsolationMergeBlockReason, s as IsolationOutcome, t as IsolationPruneResult, u as IsolationRemoval, v as IsolationRepo, w as IsolationRun, x as IsolationTaskRecord, y as IsolationTaskRef, z as IsolationTaskRepo, M as ModelUsage, O as PlanUsage, R as PrepareIntent, S as PreparedTask, T as PreservedWork, U as PreviousWork, V as RefusedRemoval, W as RepairEvidence, X as RepoGroupLayout, _ as ResearchStep, $ as ResearchStepOutcome, a1 as RunSettings, a3 as SetupFailure, a4 as ShadowedSkill, a5 as SkillAppliesTo, a6 as SkillCatalog, a9 as SkillLoadNotice, aa as SkillMetadata, ab as SkillSource, ai as TaskIsolation, aj as TaskIsolationState, ak as TaskModelAssignment, ao as TaskStatus, ap as TreeSnapshot, aq as UsageLine, as as UsageTotals, au as VerificationCheck, av as addAttemptUsage, aw as addModelUsage, ax as addPlannerUsage, ay as addUsage, az as addUsageTotals, aA as createEmptyPlan, aB as createSkillsService, aC as createTask, aD as endAttemptUsage, aE as flattenTasks, aF as flattenTasksWithParents, aG as isAwaitingReason, aH as isMeasured, aI as isSupervisorLevel, aJ as isUserMessage, aK as migratePlanState, aL as partedPromptUsage, aM as pausedOnLimit, aN as planUsage, aO as plannerContextFill, aP as rejoinPlanTree, aQ as startAttemptUsage, aR as usageLine, aS as waitsForApproval } from './Task-DZs9eKgg.js';
-import { ah as StartAdmission, w as LiveTailOptions, L as LiveTail, U as PlannerModes, at as TaskOp, u as IsolatedExecution, aa as SessionBroadcaster, b as ApplyTaskOpsResult, af as SkillLookup, ac as SessionNotice, q as EditCatalog, ab as SessionMessage, T as PlanStore, au as TaskOrchestrator, v as IsolationRunController, O as OrchestratorObserver, ar as TaskLogEvent, I as INotification, s as GlobalRunSettings, a1 as RunView, Z as RunMergeView, ax as TaskOutputSource, aO as UserSettings, al as SurfacePlan, am as SurfacePlanState } from './plan-utils-POIz5d8z.js';
-export { A as ACT_RISK, a as AUTORUN_RISK, c as ApprovalBlock, d as ApprovalStatus, e as AutoMergeTrigger, B as BlockingSubject, C as CHECKPOINT_TRUNCATE_LENGTH, f as CommandBlock, g as CommandStatus, h as CompactionBlock, i as ConversationInput, j as ConversationView, D as DiffRow, k as DiffRowKind, l as DiffStat, m as DisplayBlock, E as EMPTY_CONVERSATION, n as EMPTY_HOLD, o as EMPTY_RUN, p as EMPTY_TASK_LOG, r as ExecutionSummary, G as GatedConversation, H as HeldEdit, t as HeldEditMark, x as LocalEntry, M as MarkdownToken, y as MessageBlock, z as MessageRole, N as NOT_STARTED, F as NO_TURN, J as NewTaskFields, K as NotificationAction, P as OutputPreview, Q as PlanBlock, R as PlanMarkerStatus, S as PlanSnapshot, V as PromptHold, W as RUN_SETTINGS_DEFAULTS, Y as RunInput, _ as RunSettingsError, $ as RunTask, a0 as RunTaskStatus, a2 as RunnerLoadedBlock, a3 as STOPPED_BEFORE_START, a4 as SUPERVISOR_LEVEL_LABEL, a5 as SerializedConversationMessage, a6 as SerializedPendingTurn, a7 as SerializedPlan, a8 as SerializedTask, a9 as SerializedTaskStatus, ad as SettingsService, ae as SkillLoadBlock, ag as SkillToken, ai as SubagentBlock, aj as SubagentChild, ak as SubagentStatus, an as SurfaceTask, ao as TakenPrompt, ap as TaskAttemptSnapshot, aq as TaskControlError, as as TaskLogView, av as TaskOrchestratorDeps, aw as TaskOrchestratorOptions, ay as TaskRef, az as TaskRowAction, aA as TaskRowContext, aB as TaskRowIsolation, aC as TaskRowKind, aD as TaskRowPlacement, aE as TaskRowSubject, aF as TaskRowUsage, aG as TaskRowView, aH as TaskStatusKind, aI as ThinkingDisplayBlock, aJ as ToolBlock, aK as ToolHeadline, aL as ToolStatus, aM as TurnGate, aN as UsageBlock, aP as WAITS_FOR_APPROVAL_LABEL, aQ as aheadOfDraft, aR as applyTaskOps, aS as approvalLabel, aT as automergeSummary, aU as autorunSummary, aV as awaitingLabel, aW as blockedByLabel, aX as blockingFailures, aY as canMergeTasks, aZ as canSetDependencies, a_ as canSplitTask, a$ as capConflictFiles, b0 as classifyOutcome, b1 as coalesceTaskLog, b2 as dependencyCandidates, b3 as dependentsNotice, b4 as dependentsOf, b5 as diffRows, b6 as diffStat, b7 as diffSummary, b8 as digestTaskLog, b9 as drainNext, ba as executionSummary, bb as followTurn, bc as fromTranscript, bd as getSettingsPath, be as hasHiddenDetail, bf as holdPrompt, bg as isTaskRunning, bh as loadedSkillTokens, bi as markAction, bj as markRequestFor, bk as markdownHtml, bl as markdownTokens, bm as namedRepos, bn as newTaskFields, bo as opsEditable, bp as outputLines, bq as outputPreview, br as parseCount, bs as parseSwitch, bt as parseTaskOpsJson, bu as pastGateConfirmation, bv as reconcileApprovals, bw as reduceConversation, bx as reduceRun, by as reduceTaskLog, bz as replayTaskLog, bA as resolveTaskRef, bB as resumeLabel, bC as resumeTime, bD as runSettingsOf, bE as runnerToolSubject, bF as serializePlan, bG as serializeTask, bH as serializeTaskStatus, bI as skillTokens, bJ as skippedLabel, bK as stopTurn, bL as summarizeToolCall, bM as supervisorSummary, bN as surfacePlan, bO as surfacePlanState, bP as takeAt, bQ as taskLogForSurface, bR as taskOrderLabel, bS as taskRef, bT as taskRefOf, bU as taskRowActions, bV as taskRowView, bW as taskStartedNotice, bX as taskStatusKind, bY as textHasTaskOps, bZ as titledRefs, b_ as titledTaskRef, b$ as titledTaskRefOf, c0 as toTaskLogEvent, c1 as toolHeadline, c2 as trimToolOutput, c3 as truncateCheckpointSummary, c4 as unsendAll, c5 as unsendLatest } from './plan-utils-POIz5d8z.js';
-import { I as IApproval, y as IConfig, d as AgentProcessDeps, a as AgentAdapter, _ as OrdewellMcpServer, a6 as PlannerToolHandler, ad as ResearchShell, p as ApprovalRequest, j as ApprovalDecision, i as ApprovalAnswer, z as IRunner, a3 as PlannerBackendId, a9 as ProviderModelLists, f as AiProvider, m as ApprovalModeSetting, aq as RunnerRegistry, Z as OrchestratorOption, aD as TaskModeAgentAdapter, e as AgentStartOptions, c as AgentEvent, ai as RunnerCommand, a7 as ProjectMcpServer, n as ApprovalPolicy, B as IRunnerSession, aA as TaskCompleteArgs, r as CheckpointAnswer, av as StructuredTurnEnd, au as StructuredEvent, aC as TaskMessageFrom, ab as QueuedTaskMessage, aI as TaskStartOptions, aJ as TaskTokenScope, am as RunnerManifest, aH as TaskRunnerFlags } from './IRunner-D_UkkMbJ.js';
-export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, k as ApprovalKind, l as ApprovalMode, o as ApprovalPolicyOptions, q as ApprovalSource, C as CatalogModel, s as CheckpointArgs, t as CommandClassification, u as CommandTier, v as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, w as DENY_ALL, x as DiscoveryCommand, E as EditPlanArgs, F as FetchAllProviderModelsOptions, G as GIT_READONLY_SUBCOMMANDS, H as InvokedCommand, L as LineBuffer, J as ListModelsArgs, K as ListRunnersArgs, M as LoadSkillArgs, N as McpClientConfig, O as McpCredential, P as McpTool, Q as McpToolContext, R as McpToolReply, S as MessageTaskArgs, T as ModelCatalog, U as ModelShortcut, V as ORCHESTRATOR_SHORTCUTS, W as ORDEWELL_MCP_PATH, X as ORDEWELL_MCP_SERVER_NAME, Y as OneTaskArgs, $ as OwnerOnlyFile, a0 as PLANNER_EXECUTION_TOOLS, a1 as PLANNER_TOOLS, a2 as PlannerAllowlist, a4 as PlannerStartOptions, a5 as PlannerTokenScope, a8 as ProviderCredentialSource, aa as ProviderModelsResult, ac as REFUSED_COMMANDS, ae as ResearchShellDeps, af as RetryTaskArgs, ag as RunCommandArgs, ah as RunPlanArgs, aj as RunnerCommandKind, ak as RunnerEntry, al as RunnerFeatures, an as RunnerMcpServer, ao as RunnerMode, ap as RunnerModelDiscovery, ar as ShellDialect, as as SpawnFn, at as StandingDecision, aw as SubmitPlanArgs, ax as TASK_COMPLETE_TOOL, ay as TASK_COMPLETION_CONTRACT, az as TASK_TOOLS, aB as TaskDiffArgs, aE as TaskModeUnsupportedError, aF as TaskOutputArgs, aG as TaskQueryArgs, aK as TaskToolHandler, aL as approvalScopes, aM as classifyCommand, aN as clearResearchShellCache, aO as collectProviderCredentials, aP as commandAllowedBy, aQ as effectiveApprovalMode, aR as enabledRunners, aS as fetchAllProviderModels, aT as findRunnerCommand, aU as isGranted, aV as isRunnerApproval, aW as knownModelId, aX as mcpClientConfig, aY as ownerOnlyConfigFile, aZ as parseAllowlist, a_ as parseApprovalModeSetting, a$ as researchShellWarning, b0 as researchToolsPath, b1 as resolveModelShortcut, b2 as resolveProvider, b3 as resolveResearchShell, b4 as scopeAllowed, b5 as sharedMcpServer, b6 as toApprovalDecision, b7 as toOrchestratorOptions, b8 as toolAllowed } from './IRunner-D_UkkMbJ.js';
-import { T as ToolOutcome, I as IFileSystem, R as ReadFileOpts, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-_effm8-b.js';
-export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-_effm8-b.js';
-import { R as RunnerModeInfo } from './ModeResolver-Dy3Ef6p-.js';
-export { a as autonomyLevelLabel, p as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-Dy3Ef6p-.js';
+import { r as IsolationMergeResult, ai as Task, E as ExecutionActor, f as ExecutionRecord, g as GuardTrip, ah as SupervisorLevel, e as ExecutionCommandName, G as GuardTarget, n as IsolationLandedTask, I as IWorktreeIsolation, F as IsolationTaskStatus, J as PlanIsolation, a4 as RunnerId, $ as ResearchProgress, av as UsageRecord, _ as ResearchLogEntry, d as DiscoveredModel, L as LegacyPlanState, a5 as RunnerSessionCost, a2 as ResearchToolType, R as PlannerUsage, ap as TaskSkillSnapshot, af as SkillsService, aq as TaskSnapshot, K as PlanState, H as IsolationView, ax as Verdict } from './Task-C0o4i3Nn.js';
+export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, C as ConversationMessage, D as DEFAULT_RUNNERS, c as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as IntegrationDisposal, i as InvalidSkill, j as IsolationAvailability, k as IsolationHandoff, l as IsolationHandoffRepo, m as IsolationInactiveReason, o as IsolationLanding, p as IsolationMergeBlock, q as IsolationMergeBlockReason, s as IsolationOutcome, t as IsolationPruneResult, u as IsolationRemoval, v as IsolationRepo, w as IsolationRun, x as IsolationTaskRecord, y as IsolationTaskRef, z as IsolationTaskRepo, M as ModelUsage, N as PlanStatus, O as PlanUsage, Q as PlannerResendState, S as PrepareIntent, T as PreparedTask, U as PreservedWork, V as PreviousWork, W as RefusedRemoval, X as RepairEvidence, Y as ReplyRun, Z as RepoGroupLayout, a0 as ResearchStep, a1 as ResearchStepOutcome, a3 as RunSettings, a6 as SetupFailure, a7 as ShadowedSkill, a8 as SkillAppliesTo, a9 as SkillCatalog, aa as SkillInfo, ab as SkillLoad, ac as SkillLoadNotice, ad as SkillMetadata, ae as SkillSource, al as TaskIsolation, am as TaskIsolationState, an as TaskModelAssignment, ar as TaskStatus, as as TaskUsageSummary, at as TreeSnapshot, au as UsageLine, aw as UsageTotals, ay as VerificationCheck, az as addAttemptUsage, aA as addModelUsage, aB as addPlannerUsage, aC as addUsage, aD as addUsageTotals, aE as countedSessionCost, aF as createEmptyPlan, aG as createSkillsService, aH as createTask, aI as endAttemptUsage, aJ as flattenTasks, aK as flattenTasksWithParents, aL as isAwaitingReason, aM as isMeasured, aN as isSupervisorLevel, aO as isUserMessage, aP as migratePlanState, aQ as partedPromptUsage, aR as pausedOnLimit, aS as planUsage, aT as plannerContextFill, aU as rejoinPlanTree, aV as resumedSessionWindow, aW as startAttemptUsage, aX as taskUsageSummary, aY as usageLine, aZ as waitsForApproval } from './Task-C0o4i3Nn.js';
+import { bv as StartAdmission, bw as StartWait, aY as ResolveAll, a8 as IWebFetcher, cp as WebReadPolicy, cn as WebRead, co as WebReadDecision, aw as PendingApprovals, K as ConversationTurn, aL as PlannerModes, a6 as IAiService, I as ConversationRequest, n as AssignmentWriter, m as AssignmentScope, c1 as TaskQueryCatalog, k as AssignmentCatalog, b7 as RunnerCatalog, bl as SessionMessage, bh as SessionBroadcaster, bn as SessionNotice, aC as PlanStore, bX as TaskOrchestrator, ab as IsolationRunController, at as OrchestratorObserver, bQ as TaskLogEvent, a7 as INotification, a2 as GlobalRunSettings, aF as PlannerConversationHost, aE as PlannerConversation, av as PendingApproval, E as ConversationCompaction, a_ as RewindTarget, b6 as RunView, b1 as RunMergeView, b_ as TaskOutputSource, cl as UserSettings, ae as LiveTailOptions, ad as LiveTail, bm as SessionMeta, aK as PlannerModelStore, aJ as PlannerModelRecall, aG as PlannerModelCandidate } from './runSettingsText-BgXvajj2.js';
+export { A as ACT_RISK, a as AUTORUN_RISK, b as AdoptSessionResponse, c as ApplyTaskOpsResult, d as ApprovalAnswerResponse, e as ApprovalBlock, f as ApprovalRequestMessage, g as ApprovalStatus, h as ApprovalsResponse, i as ApproveReviewResponse, j as AskOptions, l as AssignmentIssue, o as AutoMergeTrigger, B as BlockingSubject, C as CHAT_COMMANDS, p as CHECKPOINT_TRUNCATE_LENGTH, q as CancelPlanningResponse, r as CancelResumeResponse, s as CliAgentAiService, t as CliAgentAiServiceDeps, u as CommandBlock, v as CommandDescriptor, w as CommandStatus, x as CommandsResponse, y as CompactionBlock, z as ConversationBusyError, D as ConversationCompactResponse, F as ConversationEditError, G as ConversationForkResponse, H as ConversationInput, J as ConversationRewindResponse, L as ConversationView, M as DEFAULT_WEB_READ_BUDGET, N as DaemonErrorCode, O as DecideOptions, P as DiffRow, Q as DiffRowKind, R as DiffStat, S as DisplayBlock, T as EMPTY_CONVERSATION, U as EMPTY_HOLD, V as EMPTY_RUN, W as EMPTY_TASK_LOG, X as EMPTY_TASK_LOG_FOLLOW, Y as ErrorBody, Z as ExecuteResponse, _ as ExecutionSummary, $ as ForceSendResponse, a0 as GatedConversation, a1 as GeneratePlanResponse, a3 as HEADLESS_CLI_COMMANDS, a4 as HeldEdit, a5 as HeldEditMark, a9 as IsolationDiffResponse, aa as IsolationMergeResponse, ac as LiveOutputLookup, af as LocalEntry, ag as MarkdownToken, ah as MergeGateEntry, ai as MergeGateResponse, aj as MessageBlock, ak as MessageRole, al as ModelsResponse, am as NOT_STARTED, an as NO_TURN, ao as NewTaskFields, ap as NotificationAction, aq as OUTPUT_LINES_DEFAULT, ar as OUTPUT_LINES_MAX, as as OkResponse, au as OutputPreview, ax as PendingApprovalsOptions, ay as PlanBlock, az as PlanMarkerStatus, aA as PlanResponse, aB as PlanSnapshot, aD as PlannerCommandSyntax, aH as PlannerModelChoice, aI as PlannerModelMemory, aM as PlannerNotReady, aN as PlannerNotReadyError, aO as PlannerReadinessConfig, aP as PlannerSubmission, aQ as PlannerTurnDiscardedError, aR as PlannerTurnStoppedError, aS as PlannerUsageLimitError, aT as PrdResponse, aU as PromptHold, aV as RUN_SETTINGS_DEFAULTS, aX as RemoveMessageResponse, aZ as ResolveConflictResponse, a$ as RewindTargetsResponse, b0 as RunInput, b2 as RunSettingsError, b3 as RunSnapshotFrame, b4 as RunTask, b5 as RunTaskStatus, b8 as RunnerLoadedBlock, b9 as RunnersResponse, ba as STOPPED_BEFORE_START, bb as SUPERVISOR_LEVEL_LABEL, bc as SerializedConversationMessage, bd as SerializedPendingTurn, be as SerializedPlan, bf as SerializedTask, bg as SerializedTaskStatus, bi as SessionData, bj as SessionFrame, bk as SessionListResponse, bo as SessionResponse, bp as SettingsResponse, bq as SettingsService, br as SettingsUpdateResponse, bs as SkillInvocation, bt as SkillLoadBlock, bu as SkillToken, bx as StopResponse, by as StreamStamp, bz as SubagentBlock, bA as SubagentChild, bB as SubagentStatus, bC as SurfacePlan, bD as SurfacePlanState, bE as SurfaceTask, bF as TASK_QUERY_ANSWER_MAX_CHARS, bG as TASK_QUERY_ANSWER_OR_OPS, bH as TASK_QUERY_FIELDS, bI as TASK_QUERY_PROTOCOL, bJ as TASK_QUERY_REMINDER, bK as TERMINAL_UI_COMMANDS, bL as TakenPrompt, bM as TaskAttemptSnapshot, bN as TaskControlError, bO as TaskLogAttemptsResponse, bP as TaskLogBatch, bR as TaskLogFollow, bS as TaskLogFollowInput, bT as TaskLogResponse, bU as TaskLogView, bV as TaskMessageResponse, bW as TaskOp, bY as TaskOrchestratorDeps, bZ as TaskOrchestratorOptions, b$ as TaskPlacement, c0 as TaskQuery, c2 as TaskQueryField, c3 as TaskRef, c4 as TaskRowAction, c5 as TaskRowContext, c6 as TaskRowIsolation, c7 as TaskRowKind, c8 as TaskRowPlacement, c9 as TaskRowSubject, ca as TaskRowUsage, cb as TaskRowView, cc as TaskStartResponse, cd as TaskStatusKind, ce as ThinkingDisplayBlock, cf as ToolBlock, cg as ToolHeadline, ch as ToolStatus, ci as TreeTask, cj as TurnGate, ck as UsageBlock, cm as WAITS_FOR_APPROVAL_LABEL, cq as Worded, cr as WorkspacesResponse, cs as abbreviateHome, ct as aheadOfDraft, cu as applyTaskOps, cv as approvalLabel, cw as assignmentIssue, cx as assignmentIssueText, cy as automergeSummary, cz as autorunSummary, cA as awaitingLabel, cB as blockedByLabel, cC as blockingFailures, cD as canMergeTasks, cE as canSetDependencies, cF as canSplitTask, cG as capConflictFiles, cH as classifyOutcome, cI as coalesceTaskLog, cJ as createAiService, cK as dependencyCandidates, cL as dependentsNotice, cM as dependentsOf, cN as describePlannerNotReady, cO as diffRows, cP as diffStat, cQ as diffSummary, cR as digestTaskLog, cS as drainNext, cT as executionSummary, cU as followTaskLog, cV as followTurn, cW as fromTranscript, cX as getSettingsPath, cY as hasHiddenDetail, cZ as holdPrompt, c_ as isTaskRunning, c$ as loadedSkillTokens, d0 as markAction, d1 as markRequestFor, d2 as markdownHtml, d3 as markdownTokens, d4 as namedRepos, d5 as newTaskFields, d6 as opsEditable, d7 as outputLines, d8 as outputPreview, d9 as parseCount, da as parseSwitch, db as parseTaskOpsJson, dc as parseTaskQueryJson, dd as pastGateConfirmation, de as plannerMessage, df as plannerNotReady, dg as plannerNotReadyFor, dh as plannerTranscript, di as reconcileApprovals, dj as reduceConversation, dk as reduceRun, dl as reduceTaskLog, dm as renderTaskQueryAnswer, dn as replayTaskLog, dp as resolveSkillInvocation, dq as resolveTaskRef, dr as resolveUserTaskRef, ds as resumeLabel, dt as resumeTime, du as runSettingsOf, dv as runnerToolSubject, dw as serializePlan, dx as serializeTask, dy as serializeTaskStatus, dz as skillTokens, dA as skippedLabel, dB as stopTurn, dC as subtreeIds, dD as summarizeToolCall, dE as supervisorSummary, dF as surfacePlan, dG as surfacePlanState, dH as takeAt, dI as taskLogForSurface, dJ as taskOrderLabel, dK as taskPlacement, dL as taskQuerySignature, dM as taskRef, dN as taskRefOf, dO as taskRowActions, dP as taskRowView, dQ as taskStartedNotice, dR as taskStatusKind, dS as textHasTaskOps, dT as textHasTaskQuery, dU as titledRefs, dV as titledTaskRef, dW as titledTaskRefOf, dX as toTaskLogEvent, dY as toolHeadline, dZ as trimToolOutput, d_ as truncateCheckpointSummary, d$ as unsendAll, e0 as unsendLatest, e1 as walkPlan } from './runSettingsText-BgXvajj2.js';
+import { j as ApprovalDecision, J as IApproval, L as IFileSystem, ak as ResearchShell, aj as ReadFileOpts, aU as ToolOutcome, H as GrepOptions, B as GlobOptions, y as FindSymbolOptions, M as IRunner, K as IConfig, a9 as PlannerBackendId, af as ProviderModelLists, f as AiProvider, m as ApprovalModeSetting, ac as PlannerToolHandler, ay as RunnerRegistry, a3 as OrchestratorOption, d as AgentProcessDeps, aM as TaskModeAgentAdapter, a as AgentAdapter, e as AgentStartOptions, c as AgentEvent, ap as RunnerCommand, ad as ProjectMcpServer, N as IRunnerSession, n as ApprovalPolicy, i as ApprovalAnswer, a4 as OrdewellMcpServer, aJ as TaskCompleteArgs, r as CheckpointAnswer, aE as StructuredTurnEnd, aD as StructuredEvent, aL as TaskMessageFrom, ah as QueuedTaskMessage, aR as TaskStartOptions, aS as TaskTokenScope, at as RunnerManifest, aQ as TaskRunnerFlags } from './IFileSystem-C4_mpfze.js';
+export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, k as ApprovalKind, l as ApprovalMode, o as ApprovalPolicyOptions, p as ApprovalRequest, q as ApprovalSource, C as CatalogModel, s as CheckpointArgs, t as CommandClassification, u as CommandTier, v as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, w as DENY_ALL, x as DiscoveryCommand, E as EditPlanArgs, F as FetchAllProviderModelsOptions, G as GIT_READONLY_SUBCOMMANDS, z as GREP_DEFAULT_HEAD_LIMIT, I as GrepOutputMode, O as InvokedCommand, P as LineBuffer, Q as ListModelsArgs, R as ListRunnersArgs, S as LoadSkillArgs, T as McpClientConfig, U as McpCredential, V as McpTool, W as McpToolContext, X as McpToolReply, Y as MessageTaskArgs, Z as ModelCatalog, _ as ModelShortcut, $ as ORCHESTRATOR_SHORTCUTS, a0 as ORDEWELL_MCP_PATH, a1 as ORDEWELL_MCP_SERVER_NAME, a2 as OneTaskArgs, a5 as OwnerOnlyFile, a6 as PLANNER_EXECUTION_TOOLS, a7 as PLANNER_TOOLS, a8 as PlannerAllowlist, aa as PlannerStartOptions, ab as PlannerTokenScope, ae as ProviderCredentialSource, ag as ProviderModelsResult, ai as REFUSED_COMMANDS, al as ResearchShellDeps, am as RetryTaskArgs, an as RunCommandArgs, ao as RunPlanArgs, aq as RunnerCommandKind, ar as RunnerEntry, as as RunnerFeatures, au as RunnerMcpServer, av as RunnerMode, aw as RunnerModelDiscovery, ax as RunnerModelRef, az as SEARCH_EXCLUSIONS, aA as ShellDialect, aB as SpawnFn, aC as StandingDecision, aF as SubmitPlanArgs, aG as TASK_COMPLETE_TOOL, aH as TASK_COMPLETION_CONTRACT, aI as TASK_TOOLS, aK as TaskDiffArgs, aN as TaskModeUnsupportedError, aO as TaskOutputArgs, aP as TaskQueryArgs, aT as TaskToolHandler, aW as approvalScopes, aX as classifyCommand, aY as clearResearchShellCache, aZ as collectProviderCredentials, a_ as commandAllowedBy, a$ as effectiveApprovalMode, b0 as enabledRunners, b1 as fetchAllProviderModels, b2 as findRunnerCommand, b3 as isGranted, b4 as isRunnerApproval, b5 as knownModelId, b6 as mcpClientConfig, b7 as ownerOnlyConfigFile, b8 as parseAllowlist, b9 as parseApprovalModeSetting, ba as researchShellWarning, bb as researchToolsPath, bc as resolveModelShortcut, bd as resolveProvider, be as resolveResearchShell, bf as scopeAllowed, bg as sharedMcpServer, bh as toApprovalDecision, bi as toOrchestratorOptions, bj as toolAllowed } from './IFileSystem-C4_mpfze.js';
+import { R as RunnerModeInfo } from './ModeResolver-DGK2rWHE.js';
+export { a as autonomyLevelLabel, p as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-DGK2rWHE.js';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
 import 'zod/v4';
@@ -42,10 +40,13 @@ type ExecutionCommand = {
     task: string;
     from: 'fresh' | 'session';
     message?: string;
-} | {
+}
+/** `force`: the user's force send (ADR-0023, F1), which interrupts the running turn and is read next. */
+ | {
     command: 'message_task';
     task: string;
     text: string;
+    force?: boolean;
 }
 /** `answer` is checked here rather than typed: an `allow` must reach the seam to be refused with its reason. */
  | {
@@ -64,20 +65,89 @@ type ExecutionCommand = {
     command: 'skip_task';
     task: string;
     reason?: string;
+}
+/** The user's force start: past a failed dependency or a merge gate, queued behind dependencies still under way (ADR-0035). */
+ | {
+    command: 'force_start';
+    task: string;
+}
+/** The user vouches for the task's work, which lands as a passed verdict's would; never anyone else (ADR-0029). */
+ | {
+    command: 'mark_complete';
+    task: string;
+}
+/** The user takes a completion back: the task is not started again, and held until it is retried or started. */
+ | {
+    command: 'mark_not_done';
+    task: string;
+}
+/** Stop a structured task's running turn, keeping its session: it then waits for the user's message. */
+ | {
+    command: 'interrupt_task';
+    task: string;
+}
+/** Force send a message queued behind the running turn (ADR-0023, F1); `id` is the one `message_task` answered with. */
+ | {
+    command: 'force_send_queued';
+    task: string;
+    id: string;
+}
+/** Take back a message still queued behind the running turn. */
+ | {
+    command: 'remove_queued';
+    task: string;
+    id: string;
+}
+/** Keep a task paused on a usage limit from resuming on its own at the reset: it waits for the user's Resume now or Retry. */
+ | {
+    command: 'cancel_resume';
+    task: string;
+}
+/** The user's answer to the checkpoint a task waits at: it goes on, or is told `reason` to act on. */
+ | {
+    command: 'answer_checkpoint';
+    task: string;
+    answer: 'approve' | 'reject';
+    reason?: string;
+}
+/** The user signs off the plan's review: every task in it is approved, as executing it approves them, and it runs. */
+ | {
+    command: 'approve_review';
+};
+/** What a control answers besides its line, for the surface whose button asked. */
+type CommandPayload = 
+/** `message_task`: the queued message's id, which the surface's button answers with. */
+{
+    kind: 'message';
+    id: string;
+}
+/** `force_start` queued behind dependencies still under way, rather than started: the line saying so. */
+ | {
+    kind: 'queued';
+    line: string;
+}
+/**
+ * The user's `merge_all`, merged or stopped: what the Merge all card
+ * renders. Whether it closed the run is the Session's `run_closed` (ADR-0013).
+ */
+ | {
+    kind: 'merge';
+    result: IsolationMergeResult;
 };
 /**
  * What a call came to: `message` is written for the caller, a model included,
- * to act on. `id` is the queued message's id for `message_task`, the value the
- * surface's button already answered with.
+ * to act on. A refusal carries a payload only where the act ran and stopped:
+ * a Merge all that git would not take.
  */
 type CommandOutcome = {
     ok: true;
     message: string;
-    id?: string;
+    payload?: CommandPayload;
 } | {
     ok: false;
     outcome: 'refused' | 'declined';
     message: string;
+    payload?: CommandPayload;
 };
 /** What the seam does with a valid command: run it, ask the user first, or refuse with a note the caller can act on. */
 type Consent = {
@@ -114,9 +184,9 @@ interface WaitingRequest {
     subject: string;
 }
 /**
- * What the seam reads and calls. The Session supplies it from its own public
- * operations, the ones the surfaces' buttons call, so a command lands exactly
- * as the matching button press does.
+ * What the seam reads and calls. The Session supplies it from the operations
+ * behind the surfaces' buttons, so a command lands exactly as the matching
+ * button press does, whoever asked.
  */
 interface ExecutionHost {
     /** The plan's task tree; null when there is no plan. */
@@ -125,6 +195,8 @@ interface ExecutionHost {
     planApproved(): boolean;
     /** The user approved this task: it was in the plan they executed, or they started it themselves. */
     taskApproved(taskId: string): boolean;
+    /** A task the scheduler leaves for the user to approve: added to the plan since they approved it (ADR-0035). */
+    waitsForApproval(taskId: string): boolean;
     /** A start the user consented to approves these tasks, before it acts. */
     approve(taskIds: readonly string[]): void;
     /** Full autonomy: starts follow plan approval without a question. */
@@ -146,17 +218,28 @@ interface ExecutionHost {
     maxParallel(): number;
     /** The run waits on the user to stash or skip isolation before anything starts. */
     runBlocked(): boolean;
-    /** The tasks a task's dependencies still hold it back for: unmet dependencies, or the unfinished work behind a skipped one. */
-    unmetDependencies(task: Readonly<Task>): string[];
-    /** The ancestors a task would wait on at its merge gate if it started now, whatever its status (ADR-0020). */
-    mergeGate(taskId: string): string[];
-    /** The failed tasks a task not started waits on through its dependencies (ADR-0034). */
-    blockedBy(taskId: string): string[];
+    /**
+     * Every reason the task cannot start now, from the scheduler's one start
+     * rule (ADR-0034). Takes the task, not its id: one a held edit changes or
+     * adds is judged as the edit leaves it.
+     */
+    startWaits(task: Readonly<Task>): readonly StartWait[];
     /** The runner requests waiting on a task for an answer. */
     waitingRequests(taskId: string): readonly WaitingRequest[];
     /** A start is told who asked: whether a run it opens continues the last one depends on it (ADR-0029). */
     runPlan(actor: ExecutionActor): Promise<void>;
+    /**
+     * The user's Execute while a run is under way, once it approved every task:
+     * the run takes them in, each starting once its dependencies finish. Answers
+     * the line that says so, naming how many had waited for approval.
+     */
+    joinRun(approved: number): Promise<string>;
     startTask(taskId: string, actor: ExecutionActor): Promise<void>;
+    /** Force start the task; answers the line saying it waits for its dependencies, when it was queued behind them rather than started. */
+    forceStart(taskId: string): Promise<string | undefined>;
+    markComplete(taskId: string): Promise<void>;
+    markNotDone(taskId: string): Promise<void>;
+    interrupt(taskId: string): Promise<void>;
     stopTask(taskId: string): Promise<void>;
     stopRun(): void;
     retryTask(taskId: string, actor: ExecutionActor): Promise<void>;
@@ -166,8 +249,22 @@ interface ExecutionHost {
     /** Resume a task paused on a usage limit now; see {@link TaskOrchestrator.resumeNow}. */
     resumeNow(taskId: string, message: string | undefined, actor: ExecutionActor): Promise<void>;
     messageTask(taskId: string, text: string): string;
-    denyRequest(requestId: string, note?: string): boolean;
-    /** Merge all, through the queue landings and the user's Merge all share. */
+    /** Force send (ADR-0023, F1): interrupt the running turn and deliver this next. */
+    forceMessage(taskId: string, text: string): string;
+    /** False once the message was delivered. */
+    forceSendQueued(taskId: string, id: string): boolean;
+    /** False once the message was delivered or taken back. */
+    removeQueued(taskId: string, id: string): boolean;
+    /** False when no resume was scheduled. */
+    cancelResume(taskId: string): Promise<boolean>;
+    /** The task waits at a checkpoint, and a runner is left to hear the answer. */
+    awaitsCheckpoint(taskId: string): boolean;
+    answerCheckpoint(taskId: string, approve: boolean, reason?: string): void;
+    /** Sign off the review: the plan is the user's, and runs. */
+    approveReview(): Promise<void>;
+    /** Answer a runner's request, as its card does; false once it was answered or withdrawn. */
+    answerRequest(requestId: string, decision: ApprovalDecision): boolean;
+    /** Merge all, through the queue it shares with landings. */
     mergeAll(): Promise<IsolationMergeResult>;
     /** Keep the call in the timeline, worded as `text`. */
     record(record: ExecutionRecord, text: string): void;
@@ -200,12 +297,13 @@ interface ExecutionCommandsDeps {
     now?: () => string;
 }
 /**
- * The command seam (ADR-0029, #91): the one place an execution action from
- * anyone but a button reaches the scheduler. It resolves the task, checks the
- * call against the plan's state, who asked and the user's approval, asks the
- * user where consent needs a person, runs the Session operation the matching
- * button runs, and records the call in the timeline with who asked. A refusal
- * names the task and the reason, worded for a model to act on.
+ * The command seam (ADR-0029, #91): the one place an execution action
+ * reaches the scheduler, whether the user, a planner turn or the supervisor
+ * asked. It resolves the task, checks the call against the plan's state, who
+ * asked and the user's approval, asks the user where consent needs a person,
+ * runs the Session operation behind the matching button, and records the call
+ * in the timeline with who asked. A refusal names the task and the reason,
+ * worded for whoever asked to act on ({@link voiceOf}).
  */
 declare class ExecutionCommands {
     private readonly deps;
@@ -261,8 +359,9 @@ declare class ExecutionCommands {
     private asksToApprove;
     /**
      * Who may do what without the mandate (#23): the user's own call needs no
-     * consent; a planner turn may always end or steer work, and starts it only
-     * as the autonomy level says; the supervisor's level decides for it.
+     * consent, and their own controls are theirs alone; a planner turn may
+     * always end or steer work, and starts it only as the autonomy level says;
+     * the supervisor's level decides for it.
      */
     private consent;
     /**
@@ -274,6 +373,19 @@ declare class ExecutionCommands {
     private prepareRunPlan;
     /** A start of one task: `run_task`, or a fresh `retry_task`, which also takes a task that failed or waits on the user. */
     private prepareStart;
+    /**
+     * The user's force start goes past what the scheduler waits for, so only
+     * what no start could get past is refused here; the start rule decides the
+     * rest at the claim, and a dependency still under way queues it.
+     */
+    private prepareForceStart;
+    /** Signing off the review approves every task in the plan, as executing it does: the seam records that before it acts. */
+    private prepareApproveReview;
+    private prepareMarkComplete;
+    private prepareMarkNotDone;
+    private prepareInterrupt;
+    private prepareCancelResume;
+    private prepareCheckpoint;
     private prepareContinue;
     /**
      * A pause is not a failure: the attempt stopped on its account's limit, so
@@ -284,1109 +396,49 @@ declare class ExecutionCommands {
     private prepareStop;
     private prepareStopRun;
     private prepareMessage;
+    /** A message queued behind the running turn, sent now or taken back; one delivered meanwhile is past either. */
+    private prepareQueued;
+    /**
+     * The user answers a runner's request as its card does. Anyone else only
+     * narrows or hands it on: allowing would widen the mode the plan gave the
+     * task (ADR-0029).
+     */
     private prepareAnswer;
     private prepareMergeAll;
     /**
      * A skip is a decision not to wait for the task. Running it again undoes
      * that decision, so the supervisor leaves it to the user rather than going
-     * round between the two.
-     */
-    private skippedRefusal;
-    /**
-     * A skip ends a task without a verdict and lands nothing, so it never
-     * vouches for work. Anyone but the user names why, and the supervisor only
-     * gives up on a task that already needs someone: failed, blocked, or
-     * waiting for input.
-     */
-    private prepareSkip;
-    /**
-     * Why a start is not the user's to have made, or the task it asks them to
-     * approve, or null: the user's own call is its own approval.
-     */
-    private unapproved;
-    /**
-     * The Guarded question, on the card the user answers other planner requests
-     * on. It names every task a yes approves, since a yes is the user's
-     * approval of them as Execute plan would be.
-     */
-    private question;
-    /** What was asked, as "start task #4 "Title"". */
-    private intent;
-    private refuse;
-    private keep;
-    private all;
-    private located;
-    /** A reference read against the plan as the held edit leaves it, where the handles its batch gives come first. */
-    private locateAsEdited;
-    /** A reference as a caller writes one — see {@link resolveTaskRef}. */
-    private locate;
-}
-
-/**
- * The planner's read channel: a `{"taskQuery":{...}}` reply asking Ordewell to
- * show it what the per-turn plan block deliberately leaves out.
- *
- * The plan block carries only short fields, so a planner asked to "add a line
- * to task 3's prompt" would be rewriting text it has never read. Inlining every
- * body on every turn was rejected — a twenty-task plan re-sends thousands of
- * tokens per message — so the planner asks instead, and pays for the detail
- * only on the turns it uses it.
- *
- * This module owns the wire shape and the rendering of the answer; the loop,
- * the budgets and the injection live in the Session, and the classification
- * lives in PlanRepair alongside the plan and task-ops envelopes.
- */
-/** The long fields a query may ask for. Everything else is already in the plan block. */
-declare const TASK_QUERY_FIELDS: readonly ["description", "prompt", "userSteps", "verdict", "outputSummary", "userStoriesCovered", "skills", "output"];
-type TaskQueryField = typeof TASK_QUERY_FIELDS[number];
-/** Lines a `output` read returns when the query sets no count. */
-declare const OUTPUT_LINES_DEFAULT = 80;
-/** Hard cap on `outputLines` — the tail read is bounded however the planner asks. */
-declare const OUTPUT_LINES_MAX = 400;
-/**
- * Character budget the rendered answer converges to. A running output tail is
- * the only part with no natural bound — a runner may print for minutes — so
- * the tail absorbs the clamp; everything else (task bodies, the catalog cap)
- * is bounded upstream.
- */
-declare const TASK_QUERY_ANSWER_MAX_CHARS = 20000;
-interface TaskQuery {
-    /** Task references to read in full, as {@link resolveTaskRef} reads them. */
-    tasks: string[];
-    /** Narrows what comes back. Omitted means every field in {@link TASK_QUERY_FIELDS}. */
-    fields?: TaskQueryField[];
-    /** Also return the full runner/model catalog with labels, variants and mode descriptions. */
-    catalog: boolean;
-    /** Line count for `output` reads. Clamped at render to [1, {@link OUTPUT_LINES_MAX}]. */
-    outputLines?: number;
-    /** A previous answer's next offset: the output tail then covers only what came after it. */
-    outputSince?: number;
-}
-declare function textHasTaskQuery(text: string): boolean;
-/** Parse a `{"taskQuery":...}` reply. Throws PlanParseError when the JSON is unusable. */
-declare function parseTaskQueryJson(text: string): TaskQuery;
-/** Stable identity of a query, so a turn can recognise the planner asking the same thing twice. */
-declare function taskQuerySignature(query: TaskQuery): string;
-/** What a full-catalog read is answered from. Models arrive already allowlist-filtered. */
-interface TaskQueryCatalog {
-    runners: RunnerId[];
-    models: Partial<Record<RunnerId, DiscoveredModel[]>>;
-    modes: Record<RunnerId, RunnerModeInfo[]>;
-    autonomousDefault: boolean;
-}
-/**
- * Appended when the planner has spent its read budget, or asked the identical
- * question twice. The detail still comes back — refusing it would leave the
- * planner editing text it has not read, which is the whole failure this
- * channel exists to prevent — but the turn is told to land.
- */
-declare const TASK_QUERY_ANSWER_OR_OPS: string;
-/**
- * The protocol as the planner is taught it, owned here beside the parser so the
- * two cannot drift. Both planner backends get these lines verbatim (ADR-0009):
- * a harness planner has no tool loop to reach, so the envelope is the channel.
- */
-declare const TASK_QUERY_PROTOCOL: string[];
-/** The one-line reminder the per-turn plan block carries, so the protocol has a single owner. */
-declare const TASK_QUERY_REMINDER = "- To READ a task in full (prompt, user steps, verdict, output, user stories) or the whole model/mode catalog before editing, reply with ONLY {\"taskQuery\":{\"tasks\":[\"<id or #order>\"],\"catalog\":true}} \u2014 it changes nothing, and you then reply again with your ops.";
-/**
- * Where an `output` read is answered from: the orchestrator's live capture of
- * the task's latest attempt. Injected so this module stays planner-side and
- * never imports the orchestrator.
- */
-type LiveOutputLookup = (taskId: string, opts: LiveTailOptions) => LiveTail | null;
-/**
- * Render the injected answer to one read. Never persisted — it is context for
- * the planner's next reply and nothing else — so it is built fresh from live
- * state on every query rather than cached. `liveOutput` backs the `output`
- * field; omitting it reads as "nothing captured".
- */
-declare function renderTaskQueryAnswer(query: TaskQuery, tasks: readonly Task[], catalog: TaskQueryCatalog, liveOutput?: LiveOutputLookup): string;
-
-/**
- * The SSRF guard for anything that leaves the machine on the planner's behalf.
- * An unguarded `http://169.254.169.254/` would hand a prompt-injected planner
- * the cloud metadata credentials, so every outbound host is vetted here: IP
- * literals by range, names by every address DNS answers with.
- */
-type ResolveAll = (host: string) => Promise<string[]>;
-
-/**
- * The one decision every planner web read goes through, whichever runner
- * plans and whichever path carries the bytes (ADR-0027). A fetch names the
- * URL it reads; a search names its query and the provider that receives it.
- */
-type WebRead = {
-    kind: 'fetch';
-    url: string;
-}
-/** `provider` keys the grant; `providerLabel`, when given, names it to the person asked. */
- | {
-    kind: 'search';
-    query: string;
-    provider: string;
-    providerLabel?: string;
-    note?: string;
-};
-/** A refusal's `reason` is written for the planner: it says what to do next. */
-type WebReadDecision = {
-    allowed: true;
-} | {
-    allowed: false;
-    reason: string;
-};
-interface DecideOptions {
-    /**
-     * Research subagents run in the background where nothing can prompt
-     * (ADR-0008, T6). When false, a read that would ask is refused with the gap
-     * to report, rather than raising a prompt nobody can answer.
-     */
-    prompting?: boolean;
-}
-interface WebReadPolicyOptions {
-    approval: IApproval;
-    /** The secrets Ordewell holds — provider keys, MCP tokens — read per request. */
-    secrets?: () => Iterable<string>;
-    /** Defaults to `process.env`; its credential-named values are secrets too. */
-    env?: () => Record<string, string | undefined>;
-    /** How many web reads one planner turn may make; read per request, so a settings change applies at once. */
-    budget?: () => number;
-    /** The planner turn in progress; a new one starts a new budget. */
-    turn?: () => string | undefined;
-    /** Override DNS resolution (every answer for a name) in tests. */
-    resolveHost?: ResolveAll;
-}
-declare const DEFAULT_WEB_READ_BUDGET = 40;
-declare class WebReadPolicy {
-    private readonly approval;
-    private readonly resolveHost;
-    private readonly secrets;
-    private readonly env;
-    private readonly budget;
-    private readonly turn;
-    private spent;
-    constructor(opts: WebReadPolicyOptions);
-    /**
-     * Every check that needs no network runs first, then the budget and the
-     * approval, and only then is a fetch's host resolved: a lookup is itself a
-     * request, so `<data>.attacker.example` would leave through DNS even for a
-     * read that is then excluded, over budget or declined.
-     */
-    decide(read: WebRead, opts?: DecideOptions): Promise<WebReadDecision>;
-    private subagentRefusal;
-    /**
-     * Whether a search through `provider` would run without asking anyone, for
-     * a runner whose own search raises no request and is set on or off when
-     * its session starts (ADR-0027). A zero budget disables it; no query is
-     * known yet, so secrets and individual reads cannot be checked or counted.
-     */
-    searchesUnasked(provider: string): boolean;
-    /** The last check, the one that leaves the machine: every DNS answer for the host must be public. */
-    private resolved;
-    private refuse;
-    private vetFetch;
-    private vetSearch;
-    private spend;
-    private refund;
-    private carriesSecret;
-}
-
-interface IWebFetcher {
-    /**
-     * The web-read policy's decision (ADR-0027), for a read this fetcher will
-     * carry or one a runner carries natively, such as Claude's `WebFetch`.
-     * `fetch` and `search` decide for themselves; never call both.
-     */
-    decide(read: WebRead): Promise<WebReadDecision>;
-    /** Whether a runner's own search through `provider` would run unasked; see `WebReadPolicy.searchesUnasked`. */
-    searchesUnasked?(provider: string): boolean;
-    fetch(url: string): Promise<ToolOutcome>;
-    /**
-     * Optional web search. A fetcher without it makes the `web_search` tool
-     * report itself unavailable rather than failing the turn — the same
-     * degradation `fetch` already uses when no fetcher is wired at all.
-     */
-    search?(query: string): Promise<ToolOutcome>;
-    /**
-     * A variant of this fetcher for a research subagent: same policy, cache,
-     * transport and budget, but a read that would ask a person is refused
-     * instead (ADR-0027, ADR-0008 T6). Absent means subagents get no web tools
-     * and the `fetch`/`web_search` tools report themselves unavailable.
-     */
-    forSubagent?(): IWebFetcher;
-}
-
-/**
- * A person's approvals of project MCP servers, kept across sessions
- * (ADR-0028). Keyed by repository root and scope, which names the server
- * and hashes its definition: a changed definition is a new question.
- */
-interface ProjectServerApprovals {
-    approved(repoRoot: string, scope: string): boolean;
-    remember(repoRoot: string, scope: string): void;
-}
-
-interface CliAgentAiServiceDeps extends Partial<AgentProcessDeps> {
-    /** Overrides adapter construction. Tests supply a fake agent; production picks by runner id. */
-    createAdapter?: (runner: string, deps: AgentProcessDeps) => AgentAdapter | null;
-    /** Workspace root the agent explores. Defaults to the host process's cwd. */
-    workspaceRoot?: () => string;
-    /** Where a conversation's planner tools are served (ADR-0022). Absent: no conversation can start. */
-    mcpServer?: OrdewellMcpServer;
-    /** A person's approvals of project MCP servers, kept across sessions (ADR-0028). Defaults to Ordewell's data directory. */
-    projectServerApprovals?: ProjectServerApprovals;
-}
-/**
- * A coding agent driven as Ordewell's planner (ADR-0009).
- *
- * The second transport behind `IAiService`, sitting beside `OpenAiService` and
- * `GeminiService`. It deliberately does **not** extend {@link BaseAiService}:
- * that class's body is Ordewell executing research tools on a model's behalf,
- * which is precisely the part a coding agent replaces. What it reuses instead
- * is everything above the transport — `settleReply` (the empty-reply nudge
- * and the turn's settling), the plan validator, the `ResearchProgress` events the
- * four surfaces already render. That is why this backend reaches VS Code, the
- * web UI, the CLI and the TUI without any of them learning a coding agent is
- * on the other end.
- */
-declare class CliAgentAiService implements IAiService {
-    private config;
-    private readonly runner;
-    private readonly processDeps;
-    private readonly makeAdapter;
-    private readonly workspaceRoot;
-    private environmentSecrets;
-    /** The conversation's session, from its start until the next session boundary. */
-    private session;
-    private readonly mcpServer;
-    private readonly projectServerApprovals;
-    private activeAbort;
-    constructor(config: IConfig, deps?: CliAgentAiServiceDeps);
-    hasActiveConversation(): boolean;
-    /**
-     * False when the running agent process was spawned under a model/effort the
-     * user has since changed in the picker. Unlike a vendor backend, the model
-     * is a spawn-time argument to the agent CLI (`--model`), not a per-request
-     * field — `continueConversation` sends the next turn to whatever process is
-     * already running, so a plain config read here would silently keep planning
-     * on the old model. No conversation yet is vacuously "current".
-     */
-    conversationMatchesConfig(): boolean;
-    /** Always: a conversation whose planner cannot reach the Ordewell MCP server fails to start rather than falling back to the envelopes. */
-    plannerToolsAttached(): boolean;
-    /** The agent's own session id, a resumption hint only — Ordewell's transcript is authoritative (T4). */
-    nativeSessionId(): string | null;
-    heldSecrets(): readonly string[];
-    restart(): void;
-    reset(): void;
-    startConversation(req: ConversationRequest): Promise<ConversationTurn>;
-    continueConversation(userMessage: string, onProgress: (progress: ResearchProgress) => void, signal?: AbortSignal): Promise<ConversationTurn>;
-    private openingMessage;
-    /**
-     * Drive one user message to a settled planner turn through
-     * {@link settleReply}, the loop the API backend settles through too. The
-     * tool rounds belong to the agent now, so one call is one agent turn —
-     * continued while it left subagents running in the background.
-     */
-    private runConversation;
-    /**
-     * Run one agent turn: stream its events into `ResearchProgress`, collect the
-     * reply text, and return the research steps produced. Tool calls are matched
-     * to their results by the agent's own call id — matching by tool name puts
-     * one file's body on another file's row the moment an agent runs two reads
-     * at once, which all three of these do routinely.
-     */
-    /**
-     * A turn, and then — while the agent ended it with subagents still in the
-     * background — a turn asking it to wait for them: whatever they find would
-     * otherwise be said into a closed turn, or, in a one-shot, into a session
-     * already thrown away. Bounded by `waits`, shared across a reply's sends.
-     */
-    private runTurnAwaitingAgents;
-    private runTurn;
-    /**
-     * The only way this service starts an agent, and it takes a planner start by
-     * type: the read-only boundary (ADR-0008/0009) cannot be crossed into task
-     * mode from here without changing this signature. A planner that cannot
-     * reach its tools cannot submit a plan, so it is respawned once and never
-     * left to plan without them (ADR-0025).
-     */
-    private startAdapter;
-    private newAdapter;
-    /** Whether the web-read policy lets the runner's own session-wide search run unasked now (ADR-0027). */
-    private nativeSearch;
-    /**
-     * The live agent process, restarted from its own session id if it died
-     * between turns. Resume is a hint: when it fails, the caller's next
-     * `startConversation` reseeds from Ordewell's transcript, which is the same
-     * degradation `restoreChat` already performs on every surface.
-     *
-     * Also restarted when the policy's decision on the runner's own search has
-     * changed since the process was spawned: the running thread would otherwise
-     * keep searching unasked after Full turned Guarded. Codex 0.162 applies
-     * `thread/resume`'s `config.web_search` either way (checked live).
-     */
-    private ensureAdapter;
-    /**
-     * What the planner gets of the repository's config, its runner being
-     * launched without it (ADR-0028): the instruction files, which are text, in
-     * its system prompt, and the project MCP servers it may start. Decided once
-     * per conversation, so a respawn starts the same servers without asking.
-     */
-    private repoConfig;
-    private plannerModel;
-    /**
-     * A plan from one-shot agent sessions: only what a submit_plan call
-     * accepted, never the reply text, so a plan the tool refused cannot come
-     * back in as the JSON the agent echoed. A session that ends without an
-     * accepted call is followed by one corrective session, then fails.
-     */
-    private submittedPlan;
-    /**
-     * A single agent session that answers one prompt and exits. Used by every
-     * non-conversational entry point. A plan-shaped envelope in its text
-     * streams to the plan display, as a vendor planner's one-shot does, and the
-     * prose around it is not streamed at all, since no turn is open to show it in.
-     */
-    private oneShot;
-    researchAndPlan(userDescription: string, runners: RunnerId[], modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, fs: IFileSystem, onProgress: (progress: ResearchProgress) => void, _fetcher?: IWebFetcher, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, signal?: AbortSignal): Promise<{
-        tasks: Task[];
-        researchLog: ResearchLogEntry[];
-        researchResults: string;
-    }>;
-    generatePlanDirect(userDescription: string, runners?: RunnerId[], modelsByRunner?: Partial<Record<RunnerId, DiscoveredModel[]>>, onToken?: (token: string) => void, _fs?: IFileSystem, _fetcher?: IWebFetcher, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, signal?: AbortSignal): Promise<Task[]>;
-}
-
-/**
- * The planner tools a session offers its conversation (ADR-0022). A backend
- * that can inject the Ordewell MCP server into its planner issues a planner
- * token bound to `sessionId` and these handlers; API planners use the same task read handlers directly in their tool loop.
- */
-interface PlannerToolsOffer {
-    sessionId: string;
-    handler: PlannerToolHandler;
-}
-/**
- * Everything the conversation loop needs to start planning (ADR-0002).
- * The AI service keeps the tool-use message history internally across turns;
- * the surfaces only exchange user/assistant messages with it.
- */
-interface ConversationRequest {
-    goal: string;
-    runners: RunnerId[];
-    modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>;
-    fs: IFileSystem;
-    onProgress: (progress: ResearchProgress) => void;
-    fetcher?: IWebFetcher;
-    runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
-    autonomousDefault?: boolean;
-    /**
-     * The planner model's context window when the catalog knows it. Threaded here
-     * so a usage record can carry it (and the UI can show context fill); absent
-     * when unknown, never guessed (#49).
-     */
-    contextWindow?: number;
-    /** Where tasks will run (ADR-0013, ADR-0014): in worktrees, the prompt drops file-overlap ordering and describes a repo group. */
-    isolatedExecution?: IsolatedExecution;
-    /** A plan the planner submits starts at once (ADR-0030), so the opening prompt has no outline gate. */
-    autorun?: boolean;
-    signal?: AbortSignal;
-    /**
-     * Persisted dialogue to seed a resumed conversation (session reload). The
-     * turns are injected into the message history verbatim — no LLM call happens
-     * for them; the first call is the turn opened by `initialMessage`.
-     */
-    priorHistory?: ConversationMessage[];
-    /**
-     * The user message that opens this turn. Defaults to `goal` — set it when
-     * resuming so the system prompt keeps the original goal while the turn
-     * carries the user's new message.
-     */
-    initialMessage?: string;
-    plannerTools?: PlannerToolsOffer;
-    /**
-     * The session's approval policy, which a harness planner's own tool
-     * requests are decided against as the API planner's are (ADR-0026). Absent:
-     * nobody can be asked, so they are denied.
-     */
-    approval?: IApproval;
-    /**
-     * The workspace's skill catalog. Every planner is shown the task skills it
-     * may attach; only one with tools is shown the planner skills, which load
-     * through `load_skill` alone (ADR-0024).
-     */
-    skills?: readonly SkillInfo[];
-}
-/**
- * One planner turn's outcome. The planner talks to the user (`message`),
- * commits a full plan (`plan`, a `{tasks:[...]}` JSON object), emits targeted
- * task edits (`task_ops`, a `{taskOps:[...]}` JSON object), or asks to read
- * task bodies and the full catalog before editing (`task_query`, a
- * `{taskQuery:{...}}` JSON object). The Session validates and applies task ops
- * atomically and answers queries out of its own state; the AI service only
- * parses them.
- */
-type ConversationTurn = 
-/**
- * `aborted`: the call was stopped, and `text` is only what it had by then.
- * `failed`: the call ended without a reply (a dead agent, a usage limit),
- * and `text` says why.
- */
-{
-    kind: 'message';
-    text: string;
-    researchLog: ResearchLogEntry[];
-    aborted?: boolean;
-    failed?: boolean;
-} | {
-    kind: 'plan';
-    tasks: Task[];
-    text: string;
-    researchLog: ResearchLogEntry[];
-} | {
-    kind: 'task_ops';
-    ops: TaskOp[];
-    text: string;
-    researchLog: ResearchLogEntry[];
-} | {
-    kind: 'task_query';
-    query: TaskQuery;
-    text: string;
-    researchLog: ResearchLogEntry[];
-};
-interface IAiService {
-    /** Credential values from the harness planner's effective environment, for the outbound secret check. */
-    heldSecrets?(): readonly string[];
-    /**
-     * Begin the planner conversation: collect workspace context, run the
-     * research/tool loop, and return the first planner turn. The service
-     * retains the full API message history for subsequent
-     * {@link continueConversation} calls.
-     */
-    startConversation(req: ConversationRequest): Promise<ConversationTurn>;
-    /**
-     * Feed the user's reply into the active conversation and return the next
-     * planner turn. Throws if no conversation is active.
-     */
-    continueConversation(userMessage: string, onProgress: (progress: ResearchProgress) => void, signal?: AbortSignal): Promise<ConversationTurn>;
-    /**
-     * Whether a planner conversation is currently held in memory. A branching
-     * predicate only — never a test for whether there is anything to release.
-     * The harness backend holds an OS process that outlives its conversation, so
-     * guarding {@link reset} with this leaks an agent process; call `reset`
-     * unconditionally instead.
-     */
-    hasActiveConversation(): boolean;
-    /**
-     * Optional: end the planner's live process but keep its own session id, so
-     * the next turn starts a fresh one resumed from it (ADR-0009). What a
-     * supervisor does to a planner that crashed or hung (ADR-0029). Absent where
-     * there is no process to end: the next call is a fresh request anyway.
-     */
-    restart?(): void;
-    /**
-     * Whether the active conversation (if any) still matches the planner
-     * model/effort currently configured. Optional, and true when absent: a
-     * vendor backend re-reads its model from config on every turn, so there is
-     * nothing to drift. A harness planner (ADR-0009) is the exception — its
-     * model is baked into the agent process at spawn — so only
-     * {@link CliAgentAiService} answers this for real. False tells the caller
-     * the same thing an absent conversation would: don't call
-     * `continueConversation`, restart instead so the new model takes effect.
-     */
-    conversationMatchesConfig?(): boolean;
-    /**
-     * Whether the planner reads the catalog and submits plans through Ordewell's
-     * MCP tools (ADR-0022). Optional, and false when absent: only a harness
-     * planner the server attached to has them, and every other planner keeps
-     * the per-turn catalog and the envelopes.
-     */
-    plannerToolsAttached?(): boolean;
-    /**
-     * Optional: prune bulky raw tool output out of the live conversation, in
-     * place, keeping subagent digests. Returns the characters removed. Absent
-     * where the backend holds no tool transcript to prune (a harness planner's
-     * agent owns its own context).
-     */
-    pruneContext?(): number;
-    /**
-     * One-shot research + plan for non-conversational surfaces (CLI `plan --goal`,
-     * web REST). Never asks questions — it plans with what it can find.
-     */
-    researchAndPlan(userDescription: string, runners: RunnerId[], modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, fs: IFileSystem, onProgress: (progress: ResearchProgress) => void, fetcher?: IWebFetcher, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, signal?: AbortSignal): Promise<{
-        tasks: Task[];
-        researchLog: ResearchLogEntry[];
-        researchResults: string;
-    }>;
-    generatePlanDirect(userDescription: string, runners: RunnerId[], modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, onToken?: (token: string) => void, fs?: IFileSystem, fetcher?: IWebFetcher, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, signal?: AbortSignal): Promise<Task[]>;
-    /**
-     * Release everything this service holds: the conversation, any in-flight
-     * turn, and — on the harness backend — the agent process itself. Idempotent
-     * and cheap in every implementation, so callers never gate it.
-     */
-    reset(): void;
-}
-/**
- * The single branch point between planner transports. Two of them talk HTTP to
- * an LLM vendor; the third (ADR-0009) drives a coding agent already installed
- * on the machine. Everything downstream — the plan contract, the research-step
- * stream, the four surfaces — is shared.
- */
-declare function createAiService(config: IConfig, deps?: CliAgentAiServiceDeps): IAiService;
-
-/** The dialogue record a fork carries — what {@link PlannerConversation.clone} returns. */
-interface ForkedDialogue {
-    conversationHistory: ConversationMessage[];
-    researchLog: ResearchLogEntry[];
-}
-
-/** A user's message as sent, and the skills its `/name` tokens load. */
-interface SkillInvocation {
-    text: string;
-    skills: SkillLoad[];
-}
-/**
- * A path with the home directory written `~`, for a notice or listing. On
- * Windows the drive letter's case is not significant and the separators are
- * rendered `/`, so the same skill reads alike wherever the session reloads.
- */
-declare function abbreviateHome(file: string, home?: string, platform?: NodeJS.Platform): string;
-/**
- * Resolve the `/skill-name` tokens in a message to snapshots of the skills they
- * name. Pure and exported so surfaces can resolve without a full Session. The text itself is never rewritten.
- *
- * Every distinct skill named loads, once, in the order first named. A token
- * naming no skill is plain text, wherever it stands — a whole message of
- * `/unknown` included: embedded in a sentence it is as likely to be incidental
- * text (a path, an example command) as a typo'd invocation. So is one naming
- * a skill with `user-invocable: false`, which only the model may invoke.
- */
-declare function resolveSkillInvocation(text: string, skillsService: Pick<SkillsService, 'findSkill'>, home?: string): SkillInvocation;
-/**
- * What the planner receives for a user message: the bodies of the skills it
- * loaded, then the message as the user wrote it. The one composition for a
- * live send and for a replay of the transcript, so a resumed conversation
- * hands the planner what the live one did.
- */
-declare function plannerMessage(text: string, loads: readonly SkillLoad[]): string;
-/**
- * The transcript as the planner is to see it on a replay: each user message
- * carries the skills loaded after it, composed by {@link plannerMessage}, and
- * the load entries themselves are folded away. Sessions saved before skill
- * loads existed hold the expanded text in the message and replay unchanged.
- */
-declare function plannerTranscript(history: readonly ConversationMessage[]): ConversationMessage[];
-
-/**
- * The planner turn (see CONTEXT.md): the one piece of planner work that holds
- * the conversation, from its claim to its settled outcome. Its signal is what a
- * stop aborts.
- */
-declare class PlannerTurn {
-    private readonly controller;
-    private dropped;
-    private forced;
-    get signal(): AbortSignal;
-    /** The plan it was answering was dropped under it, so nothing it settles may land. */
-    get abandoned(): boolean;
-    /** A force send stopped it, not the user: the forced turn follows. A turn already stopped stays the user's stop. */
-    get forceSent(): boolean;
-    stop(by?: 'force_send'): void;
-    abandon(): void;
-}
-/** What a planner turn may change: the whole plan, or tasks through edits. */
-type PlanChange = 'plan' | 'edit';
-/**
- * A wake-up turn (ADR-0029): a supervisor's turn on wake-up digests alone, no
- * user message in it. What it may do is its level's, decided by the host.
- */
-interface WakeUpTurn {
-    /** Reads the turn may make, in place of a user message's caps. */
-    readBudget: number;
-    /**
-     * Why a whole plan, or a task edit, is refused in this turn, worded for the
-     * model; undefined when its level allows it. Asked when the change is made
-     * and again as it lands, so a level lowered during the turn applies at once.
-     */
-    refused(change: PlanChange): string | undefined;
-    /** Told to the model after the digests and never saved, like the plan block: who it is in this turn, and what it may do. */
-    brief?: string;
-}
-/** A read made through a planner tool: refused once the turn's budget is gone, else answered, told to land when the budget asks it to. */
-type ToolRead<T> = {
-    status: 'refused';
-} | {
-    status: 'answered';
-    value: T;
-    landNow: boolean;
-};
-/** A plan or task edit handed to the open turn over a channel other than its reply (ADR-0022). */
-type PlannerSubmission = {
-    kind: 'plan';
-    tasks: Task[];
-} | {
-    kind: 'task_ops';
-    ops: TaskOp[];
-};
-/** Everything (re)opening a conversation needs besides the dialogue itself. */
-type ConversationOpening = Omit<ConversationRequest, 'goal' | 'onProgress' | 'signal' | 'priorHistory' | 'initialMessage'>;
-/**
- * What the conversation needs from the session that hosts it. The session keeps
- * plan state, persistence and scheduling; the conversation reaches them only
- * through here, so a fake host is enough to drive it.
- */
-interface PlannerConversationHost {
-    /** The plan the transcript lives on (`conversationHistory`, `researchLog`). */
-    plan(): LegacyPlanState | null;
-    goal(): string;
-    aiService(): IAiService;
-    onProgress(progress: ResearchProgress): void;
-    /** Fresh discovery, allowlist-filtered the way the system prompt shows it. */
-    opening(runners: RunnerId[]): Promise<ConversationOpening>;
-    /** What the per-turn catalog block and every read draw from, as of now. */
-    catalog(): TaskQueryCatalog;
-    /** Whether autorun is on now (ADR-0030); the planner is told in the turn after it changes. */
-    autorun(): boolean;
-    /** Run updates no turn has carried yet, taken by the turn that asks: the next turn is told, whoever opens it. */
-    takeRunUpdates(): string[];
-    tasks(): readonly Task[];
-    /**
-     * The orchestrator's live capture for a task's latest attempt, backing the
-     * `output` field of a read. Injected the same way as the catalog so the
-     * conversation never reaches into execution state directly.
-     */
-    liveOutput: LiveOutputLookup;
-    isExecuting(): boolean;
-    /** The session's single mutation ritual: op → persist → notify (default: the plan). */
-    mutate(op: () => boolean, notify?: () => void): LegacyPlanState | null;
-    broadcast: SessionBroadcaster;
-    /** `turnId`: the planner turn whose commit this is, when one is. */
-    broadcastPlan(turnId?: string): void;
-    /** Validate a batch against live state. Pure — nothing is applied. */
-    validateOps(ops: TaskOp[]): ApplyTaskOpsResult;
-    /** The workspace's skill catalog under its repo group's layout, which the skills a plan or edit attaches are checked against. */
-    taskSkills(): SkillLookup;
-    /** Tell the user something the transcript does not carry. */
-    notice(level: SessionNotice['level'], message: string): void;
-    /** Load planner-produced tasks: an edit keeps run state, a commit starts over. Returns how many landed. */
-    adoptTasks(tasks: readonly Task[], how: 'edit' | 'commit'): number;
-    capturePrd(text: string): void;
-    /** The planner turn was stopped or abandoned: whatever it is waiting on (a parked approval) will never be answered. */
-    turnAborted(): void;
-    /** A planner turn let the conversation go, so the next one may take it. */
-    turnReleased?(): void;
-}
-/**
- * A conversation edit (rewind, fork) the conversation refused because the
- * request itself is wrong — no such message, nothing to fork. Transport-agnostic
- * like `PlanEditError`: a route maps it to a status, core carries none.
- */
-declare class ConversationEditError extends Error {
-    constructor(message: string);
-}
-/**
- * Refused because a planner turn is in flight. Distinct from a bad request:
- * the same call succeeds once the turn settles, and the turn would otherwise
- * append its reply to a transcript that no longer holds the message it
- * answers.
- */
-declare class ConversationBusyError extends ConversationEditError {
-    constructor(operation: string);
-}
-/**
- * A planner turn that settled after the plan it was answering was dropped (a
- * new plan, another session adopted, the session closed), or after its call
- * was cut off by something other than its own stop. Nothing it produced was
- * committed: landing it would write one session's reply into another's
- * transcript.
- */
-declare class PlannerTurnDiscardedError extends Error {
-    constructor(options?: ErrorOptions);
-}
-/**
- * The user stopped the turn and the backend reported that as a thrown error
- * rather than a settled reply. Typed so a surface can stay quiet for it without
- * reading the message: some SDKs' abort errors are plain `Error`s by name, and
- * a real failure can mention "aborted" too.
- */
-declare class PlannerTurnStoppedError extends Error {
-    constructor(options?: ErrorOptions);
-}
-/** A user message a rewind can fork the conversation from just before. */
-interface RewindTarget {
-    /** Position in the transcript — what {@link PlannerConversation.cloneBefore} takes. */
-    index: number;
-    preview: string;
-    /** The whole message — the preview cuts it to one line, and a surface confirming the rewind quotes it. */
-    content: string;
-    timestamp: string;
-}
-/** What a rewind forks from, and the message it lands just before. */
-interface RewoundDialogue {
-    dialogue: ForkedDialogue;
-    rewoundMessage: string;
-}
-/** What a compaction left behind. */
-interface ConversationCompaction {
-    summary: string;
-    /** Transcript entries kept verbatim after the summary entry. */
-    keptMessages: number;
-}
-/** A point a failed turn returns the dialogue to. Opaque outside this module. */
-interface TranscriptSnapshot {
-    readonly plan: LegacyPlanState;
-    readonly history: ConversationMessage[] | undefined;
-    readonly researchLog: ResearchLogEntry[] | undefined;
-    readonly persisted: number;
-    readonly savedInBackground: number;
-}
-interface ReplyOptions {
-    signal?: AbortSignal;
-    /**
-     * Run inside the mutation that lands the turn's outcome — the edit, the
-     * plan or the reply — so what the caller drops with it (the inputs the turn
-     * answered) leaves disk in the same save.
-     */
-    onCommit?: () => void;
-    /** Wake-up digests delivered with this turn (ADR-0029), oldest first, ahead of the user's message if there is one. */
-    wakeUps?: readonly string[];
-    /** Set when the turn is a wake-up's alone. */
-    wakeUp?: WakeUpTurn;
-    /** The user's message was force sent: the turn replaces the one it stopped (ADR-0023). */
-    forced?: boolean;
-}
-/**
- * The planner conversation (ADR-0002), end to end: the persisted dialogue
- * record, the live model context behind it, and every turn from the user's
- * message to a settled, persisted outcome.
- *
- * It is the only writer of `conversationHistory` and of the planner's
- * `researchLog`. The writes land on the host's plan object — which is what the
- * session persists and broadcasts — but only ever inside the host's mutation
- * ritual or ahead of a turn that will either reach it or be rolled back.
- *
- * The live model context (a vendor service's message list, a harness planner's
- * process and native session id) is disposable: {@link reset} drops it and the
- * next turn is replayed from the transcript. That is what lets the transcript
- * be replaced by a summary, or copied into a fork, without the model's memory
- * drifting from it.
- */
-declare class PlannerConversation {
-    private readonly host;
-    /** Bumped on every persist, so a rollback can tell whether its writes already reached disk. */
-    private persisted;
-    /** Saves an execution event made while a turn may be in flight; see {@link restore}. */
-    private savedInBackground;
-    /** What the planner was last told of autorun: by its opening prompt, or a turn's block since. */
-    private toldAutorun;
-    private live;
-    private openTurn;
-    constructor(host: PlannerConversationHost);
-    get transcript(): readonly ConversationMessage[];
-    /** Whether a planner turn holds the conversation. */
-    get isTurnInFlight(): boolean;
-    /** Stop the planner turn in flight; it settles as stopped. False when none is. */
-    stopTurn(by?: 'force_send'): boolean;
-    /**
-     * Drop the planner turn in flight together with the plan it was answering:
-     * it is stopped, whatever it settles is discarded, and the conversation is
-     * free at once rather than when the abandoned turn finishes unwinding.
-     */
-    abandonTurn(): void;
-    /**
-     * Free the conversation from a turn that did not end when stopped — a hung
-     * wake-up (ADR-0029). Unlike {@link abandonTurn} the plan stays, so what the
-     * turn wrote is taken back as its failure would have, and its end is
-     * announced: the turn itself may never get there.
-     */
-    abandonHungTurn(): void;
-    /**
-     * Run planner work that is not a conversation turn — one-shot plan
-     * generation — as the planner turn, so it is stopped, refused and superseded
-     * like one. It starts a fresh plan, so it supersedes the turn in flight.
-     */
-    hold<T>(signal: AbortSignal | undefined, body: (turn: PlannerTurn) => Promise<T>): Promise<T>;
-    /**
-     * Take the conversation for a new planner turn. A caller's own signal stops
-     * the turn too; the relay is detached on release because a caller may reuse
-     * that signal, and a stale listener would stop the next turn with it.
-     */
-    private claim;
-    /** The user turn being answered, for what the host raises during it — an approval the turn's research asks for. */
-    get currentTurnId(): string | undefined;
-    /** The open turn's wake-up rules, when the supervisor is answering it rather than the user's message. */
-    get currentWakeUp(): WakeUpTurn | undefined;
-    recordPlannerSkill(skill: SkillLoad): boolean;
-    /**
-     * Hand the open turn a plan (already validated) or a task edit. The turn
-     * settles with it exactly as with the same plan or ops parsed out of its
-     * reply, and it wins over any envelope that reply carries. A later
-     * submission replaces an earlier one. False when no user turn is open.
-     */
-    submit(submission: PlannerSubmission): boolean;
-    /**
-     * Tell surfaces what the turn's edit would leave, from the same applier that
-     * lands it, so an edit that would not apply shows nothing. It stays shown
-     * from the moment it is handed in until it lands, is refused, or the turn
-     * ends: the backend's reply claims it, but it has not landed by then.
-     */
-    private showHeld;
-    private clearHeld;
-    /**
-     * The edit the open turn already holds, for a further edit in the same reply
-     * to join rather than replace. Empty when it holds nothing; null when it holds
-     * a whole plan, which an edit cannot be layered on.
-     */
-    pendingOps(): TaskOp[] | null;
-    /**
-     * A read the planner makes through a tool. It spends the same per-turn budget
-     * as an envelope read, so a planner cannot read more by switching channels:
-     * past the soft limit, or on a repeated question, the answer still comes but
-     * is told to land the turn; at the hard limit it is refused. `signature`
-     * names the question, for the repeat check.
-     */
-    read<T>(signature: string, answer: () => Promise<T>): Promise<ToolRead<T>>;
-    /** Whether the model still holds this conversation in memory. */
-    get isActive(): boolean;
-    append(role: ConversationMessage['role'], content: string, opts?: {
-        timestamp?: string;
-        kind?: ConversationMessage['kind'];
-    }): void;
-    private appendEntries;
-    /** Swap the whole transcript. The live context no longer matches it, so pair with {@link reset}. */
-    replace(messages: readonly ConversationMessage[]): void;
-    snapshot(): TranscriptSnapshot | null;
-    /**
-     * Put the dialogue back where {@link snapshot} found it — unless anything
-     * was persisted since, because then memory already matches disk and every
-     * surface, and undoing it would erase work the user has seen land. Also a
-     * no-op once a different plan has been adopted.
-     *
-     * A background save (a task settling mid-turn) wrote the turn's writes to
-     * disk without landing anything the user saw, so it does not stop the undo;
-     * the undo is saved in turn, or a reload would bring the writes back.
-     */
-    restore(snapshot: TranscriptSnapshot): boolean;
-    /**
-     * The host calls this after every persist. `background` is a save no call
-     * of the user's made — an execution event landing mid-turn.
-     */
-    markPersisted(opts?: {
-        background?: boolean;
-    }): void;
-    /**
-     * Drop the live model context. Idempotent; the harness backend holds an OS
-     * process here, so callers never gate it on {@link isActive}.
-     */
-    reset(): void;
-    /**
-     * The user messages a rewind may land before. The opening message is the
-     * goal: cutting it leaves a conversation about nothing, which is a new
-     * session, not a rewind. After a compaction the summary entry, always
-     * first, plays the goal's part: what it replaced is gone, so a rewind stops
-     * at it.
-     */
-    rewindTargets(): RewindTarget[];
-    /**
-     * Replace the transcript with a summary of it, keeping the last two
-     * exchanges as they were, and drop the live context so the next message
-     * replays from the shorter record.
-     *
-     * The summary is one hidden turn through whichever planner is configured —
-     * on the live context when it still matches, replayed from the transcript
-     * when not — so the compaction is the same for a vendor API and a harness
-     * agent. Whatever the turn emits besides the summary is discarded, ops
-     * included: it condenses the conversation, never the plan. Nothing is
-     * written until the summary is in hand, so a failed or stopped turn leaves
-     * the transcript exactly as it was.
-     */
-    compact(signal?: AbortSignal): Promise<ConversationCompaction>;
-    private summarize;
-    /**
-     * A copy of the dialogue record for a forked session to carry. Refused
-     * mid-turn: the copy would hold the user's message without the reply to it.
-     * The live context is not part of it — the fork replays from this record on
-     * its first turn, like any adopted session.
-     */
-    clone(): ForkedDialogue;
-    /**
-     * A copy of the dialogue as it stood just before the user message at
-     * `index` (a position from {@link rewindTargets}) — what a rewind forks
-     * from — plus that message's full text, for a surface to offer back. This
-     * conversation is not touched. The research trace is cut at the same point
-     * by time: its entries carry no link to the message that caused them.
-     */
-    cloneBefore(index: number): RewoundDialogue;
-    /**
-     * What the skill check of a landed plan or edit warned about, kept in the
-     * transcript so every surface shows it, on reload too, and not only the
-     * planner that may have read it in a tool result. Call inside the host's
-     * mutation ritual, so the broadcast plan carries it.
-     */
-    recordSkillWarnings(warnings: readonly string[], timestamp?: string): void;
-    /**
-     * A call at the command seam (ADR-0029), kept where it happened in the
-     * dialogue: a reload shows it, and a planner replayed from the transcript
-     * knows what was started or stopped, and by whom. Call inside the host's
-     * mutation ritual.
-     */
-    recordExecution(record: ExecutionRecord, text: string): void;
-    /**
-     * Open the conversation on the host's fresh plan: the goal is its first
-     * message. `prepare` (discovery) runs inside the turn, so a stop reaches it.
-     */
-    start(goal: SkillInvocation, prepare: () => Promise<ConversationOpening>, signal?: AbortSignal): Promise<LegacyPlanState>;
-    /**
-     * Every later user message, from the transcript append to a persisted
-     * outcome. A turn that throws before anything was persisted takes its own
-     * writes back out, so session memory never drifts from disk and the UI.
-     */
-    reply(message: string | SkillInvocation, options?: ReplyOptions): Promise<LegacyPlanState>;
-    private replyTurn;
-    /**
-     * A wake-up turn lands only a real answer. Stopped — by the user, or by its
-     * timeout — it lands nothing, not the fragment a backend hands back; a
-     * failure is thrown rather than shown, for the supervisor to retry
-     * (ADR-0029).
-     */
-    private assertWakeUpAnswered;
-    private assertIdle;
-    /**
-     * Refuse to land a turn that no longer belongs here: it was abandoned, its
-     * plan is no longer the host's, or its call was cut off by something other
-     * than its own stop (`IAiService.reset` under a plan change) — what such a
-     * call hands back is a fragment of an answer to a dialogue that is gone.
-     */
-    private assertCurrent;
-    /**
-     * {@link assertCurrent} on the far side of an await that precedes a plan
-     * mutation: the skill check waits on git, and a stop, rewind or session
-     * switch in that window drops the edit instead of landing it on whatever
-     * plan is current by then. A stop counts here because nothing has landed
-     * yet — the user asked for the turn to end before it changed the plan.
-     */
-    private assertStillCurrent;
-    /**
-     * A live conversation is only safe to continue in-place when it also
-     * matches the model/effort configured right now — a harness planner's
-     * running process was spawned with the old one baked in and cannot pick up
-     * a switch (ADR-0009). Otherwise the turn resumes from the transcript.
-     */
-    private canContinueLive;
-    /**
-     * Bracket one user turn with its start and end, under an id minted here:
-     * the turn is where the stream a surface draws begins and ends, and only the
-     * conversation sees all of it — every backend call, read and retry.
-     */
-    private userTurn;
-    private requirePlan;
-    /** The message as typed, then one entry per skill it loaded, sharing its timestamp so a reload keeps them together. */
-    private userEntries;
-    private recordUser;
-    /**
-     * Write the turn's held inputs inside the mutation that lands the outcome —
-     * call at its top, before the assistant entries, so the transcript reads in
-     * the order it happened and the inputs leave the plan in the save that
-     * carried their answer (ADR-0029). They go back where the turn opened, ahead
-     * of whatever it wrote as it ran (a planner skill load, a command at the
-     * seam), not at the end.
-     */
-    private commitInput;
-    private recordResearch;
-    /**
-     * Reopen the model context from the transcript — because the in-memory one
-     * is gone (session reload, extension restart), or because it is stale
-     * against the planner config now in effect. No LLM call happens for the
-     * replayed turns; the first call is the one the user's message opens.
-     */
-    private resume;
-    /**
-     * Answer every read the planner emits until it says something else.
-     *
-     * The channel is a text envelope rather than a registered tool because the
-     * protocol has to be identical on both planner backends (ADR-0009): Ordewell
-     * owns a tool loop only in the API case, and a harness planner running as a
-     * coding-agent subprocess can only be reached this way.
-     *
-     * Draining here — outside {@link repairLoop} — is what keeps reads free of
-     * the repair budget. A planner that looks a task up and *then* fumbles its
-     * ops JSON still gets its two corrective retries; charging it for the read
-     * would cost it the chance to fix the edit.
-     */
-    private drainTaskQueries;
-    /**
-     * The backend's answer, with what was handed in while it ran standing in
-     * for whatever its reply carried. Taken once: a corrective re-send after a
-     * rejected edit must not settle on the same submission again. A stopped
-     * turn commits nothing, the same as a stopped reply with a plan in it.
+     * round between the two.
      */
-    private claimSubmission;
+    private skippedRefusal;
     /**
-     * Render one read out of live state. Never persisted to the transcript: the
-     * detail is context for the planner's next reply, and re-sending it on every
-     * later turn is exactly the cost this channel exists to avoid.
+     * A skip ends a task without a verdict and lands nothing, so it never
+     * vouches for work. Anyone but the user names why, and the supervisor only
+     * gives up on a task that already needs someone: failed, blocked, or
+     * waiting for input.
      */
-    private taskQueryAnswer;
+    private prepareSkip;
     /**
-     * Drive a planner turn, its reads already drained, to a persisted, broadcast
-     * outcome. Task edits apply atomically; validation failures are fed back to
-     * the model for up to 2 silent retries, then surfaced as a message with the
-     * plan untouched. The first turn and every later turn route through here —
-     * one path, not two.
-     */
-    private settle;
-    /** A name not found at submit only warns: a task the attaching one depends on may create it. */
-    private warnSkills;
-    /** Validate + commit a task_ops turn atomically. Returns the errors on rejection (plan untouched). */
-    private applyTaskOps;
-    /** The edit was refused as it landed: what it showed is not coming. */
-    private refusedHeld;
-    /** Commit a settled (non-task_ops) turn through the host's mutation ritual. */
-    private commit;
-    /**
-     * The autorun rule (ADR-0030) when it changed since the planner was last
-     * told — in the opening prompt or an earlier turn — so a switch mid-
-     * conversation reaches its next turn without repeating in every one.
-     */
-    private autorunBlock;
-    private runUpdatesBlock;
-    /**
-     * The catalog the planner may actually draw from — model ids and task-mode
-     * ids, per runner in the plan — emitted on EVERY turn, before any plan exists
-     * or after. The system prompt shows this once at conversation start; a long
-     * clarifying conversation outlives that single showing and the planner
-     * starts misquoting it, so this re-states it per turn instead.
-     *
-     * The host's catalog is allowlist-filtered, so a restricted allowlist stays a
-     * hard bound on every turn, and reads the plan's runners live, so a runner
-     * admitted mid-session by a retarget is shown like every other. A planner
-     * with Ordewell's tools gets a reminder to read the catalog instead.
+     * Why a start is not the user's to have made, or the task it asks them to
+     * approve, or null: the user's own call is its own approval.
      */
-    private catalogBlock;
+    private unapproved;
     /**
-     * The "you are here" block for post-plan chat: current tasks with stable
-     * references, plus the read and edit protocols. Injected per turn (never
-     * persisted) so the model always sees live statuses — including which tasks
-     * are locked by a running execution.
+     * The Guarded question, on the card the user answers other planner requests
+     * on. It names every task a yes approves, since a yes is the user's
+     * approval of them as Execute plan would be.
      */
-    private planContextBlock;
-    /** One line per task, subtasks indented under their parent, with stable references — null until the plan has tasks. */
-    private currentPlanLines;
-}
-
-interface SessionMeta {
-    id: string;
-    goal: string;
-    runners: RunnerId[];
-    taskCount: number;
-    status: PlanStatus;
-    createdAt: string;
-    updatedAt: string;
-}
-interface SessionData {
-    meta: SessionMeta;
-    /** The full plan state — including conversationHistory, prdMarkdown, and queuedMessages. */
-    plan: LegacyPlanState;
+    private question;
+    /** What was asked, as "start task #4 "Title"". */
+    private intent;
+    private refuse;
+    private keep;
+    private all;
+    private located;
+    /** A reference read against the plan as the held edit leaves it, where the handles its batch gives come first. */
+    private locateAsEdited;
+    /** A reference as a caller writes one — see {@link resolveTaskRef}; the user's as they type one ({@link resolveUserTaskRef}). */
+    private locate;
 }
 
 /**
@@ -1701,78 +753,6 @@ declare class HttpWebFetcher implements IWebFetcher {
     private hop;
 }
 
-/**
- * The bridge between "core needs an answer" and "a human somewhere is looking
- * at a UI". Core cannot prompt: the human may be at a browser, a TUI, a CLI
- * stream, or a VS Code webview, and on the web server they are on the far end
- * of a socket. So the Session parks a promise here, announces the request
- * through the normal broadcast seam, and every surface answers through the
- * same `resolve(id, granted)` call.
- *
- * Timeouts are load-bearing rather than defensive: a planner turn that blocks
- * forever on an unanswered prompt would hang the whole research loop with no
- * visible cause. On expiry the request resolves to denied and the model gets a
- * normal, actionable tool result. A task runner's request is the exception
- * (ADR-0018, A1): the runner is parked on it rather than a research loop, and
- * it waits for a person — or the supervisor — however long that takes.
- */
-interface PendingApproval {
-    id: string;
-    request: ApprovalRequest;
-    createdAt: string;
-}
-interface PendingApprovalsOptions {
-    /** Denies and resolves after this long with no answer. Default 5 minutes. */
-    timeoutMs?: number;
-    /** Announce a new request to the surfaces. */
-    onRequest?: (pending: PendingApproval) => void;
-    /** Announce that a request is no longer actionable (answered or expired). */
-    onSettled?: (id: string, granted: boolean, settled: {
-        request: ApprovalRequest;
-        decision: ApprovalDecision;
-    }) => void;
-}
-interface AskOptions {
-    /**
-     * An id the caller already announced the request under. One still in use is
-     * refused — denied at once — rather than overwriting the request that has it.
-     */
-    id?: string;
-    /** Wait for an answer however long it takes. */
-    noTimeout?: boolean;
-    /**
-     * Given the answer as the request settles, before anything awaiting the
-     * promise runs: a caller about to tear down what asked (a runner being
-     * stopped) must deliver the answer before it goes.
-     */
-    onDecision?: (decision: ApprovalDecision) => void;
-}
-declare class PendingApprovals {
-    private readonly opts;
-    private readonly entries;
-    private readonly listeners;
-    constructor(opts?: PendingApprovalsOptions);
-    /** Hear each new request once it is announced — the supervisor wakes on a runner's (ADR-0029). */
-    listen(listener: (pending: PendingApproval) => void): () => void;
-    /** Park a request and return the promise the approval policy awaits. */
-    ask(request: ApprovalRequest, options?: AskOptions): Promise<boolean>;
-    /** Park a request whose answer is more than yes or no. */
-    decide(request: ApprovalRequest, options?: AskOptions): Promise<ApprovalDecision>;
-    /**
-     * Answer one request. Returns false when the id is unknown or already
-     * settled. "Allow for this task" on a request that did not offer it is a
-     * plain allow: no grant is made that the requester never proposed.
-     */
-    resolve(id: string, answer: ApprovalAnswer): boolean;
-    /** Everything still awaiting an answer — replayed to a surface that connects late. */
-    outstanding(): PendingApproval[];
-    /**
-     * Deny everything in flight, or only the requests `which` picks. Called on
-     * abort and on session reset.
-     */
-    clear(which?: (request: ApprovalRequest) => boolean, note?: string): void;
-}
-
 /**
  * Carries a structured task's tool requests to the session's one approval
  * seam (ADR-0018, A1), so a runner's request is answered through
@@ -2157,6 +1137,35 @@ interface Adr0013PlanIsolation {
  */
 declare function migratePlanIsolation(state: PlanIsolation | Adr0013PlanIsolation): PlanIsolation;
 
+/** The part of a run's handoff a Merge confirmation is worded from; structural, so each surface passes the handoff it holds. */
+interface MergeWordingHandoff {
+    repos: readonly {
+        path: string;
+        baseBranch?: string;
+        landed: readonly unknown[];
+    }[];
+}
+/**
+ * Whether the run spans more than a lone repo at the workspace root. A group of
+ * one at `.` is worded and drawn exactly as it was before repo groups; anything
+ * else names its repos.
+ */
+declare function isRepoGroup(handoff: {
+    repos: readonly {
+        path: string;
+    }[];
+}): boolean;
+/** The repos Merge all will merge: those with work on their integration branch, else all of them. */
+declare function reposWithWork(handoff: MergeWordingHandoff): string[];
+/**
+ * What a Merge confirmation says the branch lands on: the branch the run
+ * started on, which Merge all insists is checked out. A repo that started
+ * detached has none, and keeps the old wording.
+ */
+declare function mergeTarget(handoff: MergeWordingHandoff): string;
+/** The refusal Merge all makes when a repo is on another branch, for a confirmation to warn of; empty when no repo named a branch. */
+declare function checkoutRule(handoff: MergeWordingHandoff): string;
+
 interface ILogger {
     warn(scope: string, message: string, err?: unknown): void;
 }
@@ -2187,6 +1196,8 @@ interface ResearchTurn {
     finishReason?: string;
     /** Exact prompt tokens this turn consumed, when the provider reports usage — drives proactive compaction. */
     promptTokens?: number;
+    /** The segment `text` streamed under, where the provider streams it. */
+    segmentId?: string;
 }
 interface ResearchChat {
     sendMessage(text: string, signal?: AbortSignal): Promise<ResearchTurn>;
@@ -2285,8 +1296,12 @@ declare class GeminiService extends BaseAiService implements IAiService {
     private genAI;
     private genAIKey;
     private model;
+    /** The id `model` was made for; the SDK's own `model.model` is its `models/…` resource path. */
+    private modelId;
     constructor(config: IConfig);
     private init;
+    /** The planner model picked for this session, as the API names it. */
+    private plannerModel;
     private getPlanningModel;
     ensureInit(): void;
     reset(): void;
@@ -2441,13 +1456,15 @@ declare class ModelResolver {
     getCachedRunnerModels(runner: string): DiscoveredModel[];
     getCachedPickerOptions(): OrchestratorOption[];
     /**
-     * The planner model's context window, from whatever catalog is already
-     * cached (#49): a vendor model comes from the picker catalog, a harness
-     * planner's model from the runner's own discovered models. Reads only —
-     * never triggers a fetch or discovery of its own, so an unknown window stays
-     * unknown and context fill is omitted rather than guessed.
+     * A model's context window from whatever catalog is already cached (#49),
+     * for a usage record whose reporter stated none: a vendor's model from the
+     * picker catalog (its own `/models` endpoint), a runner's model from that
+     * runner's own discovered listing. `source` is the record's reporter, and
+     * `model` the id it named. Reads only — never triggers a fetch or discovery
+     * of its own, so an unknown window stays unknown and context fill is
+     * omitted rather than guessed.
      */
-    contextWindowFor(modelId: string): number | undefined;
+    contextWindowFor(source: string, model: string): number | undefined;
     invalidate(): void;
 }
 
@@ -2815,16 +1832,17 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     /** An interrupt was sent during the current turn, so an aborted result is that interrupt, not a failure. */
     private interruptRequested;
     private readonly permissions;
-    /** Whether this turn has already emitted reply text — see {@link handleLine}. */
-    private turnHasText;
-    /** The text block streaming now follows earlier reply text, so its first delta opens the paragraph. */
-    private pendingBreak;
-    /** The model answering the planner's current message, as its `message_start` named it. */
+    /** This turn's runs of reply text, each a text block named `<message id>:<block index>`. */
+    private replyRuns;
+    /** The model answering the planner's current message, and the message's id, as its `message_start` named them. */
     private plannerModel;
+    private streamingMessage;
+    /** The message the last `assistant` line was part of, and how many of its blocks the lines have carried. */
+    private lineMessage;
     /**
-     * The session's `total_cost_usd` as last reported. Undefined after a resume:
-     * the CLI restores the resumed session's running total, and what Ordewell
-     * already counted of it is not ours to know here.
+     * The session's `total_cost_usd` as last counted. A resume starts from what
+     * was counted of that session before, and is undefined without it: the CLI
+     * restores the session's running total, which holds turns counted earlier.
      */
     private reportedCostUsd;
     private reportedModelCostUsd;
@@ -2865,7 +1883,23 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     private terminalOnly;
     /** Whether this process's `runner_loaded` went out: its first `init` sends it. */
     private loadedReported;
+    /** The models `initialize` listed, which turn the ids the CLI reports back into the ones a plan holds. */
+    private listedModels;
+    /** The id the task's main thread last reported answering on. */
+    private mainModel;
+    /** What the plan should say the task runs: its spawn's model, then each switch followed. */
+    private followedModel;
+    /**
+     * Model commands sent through the chat whose switch has not been seen yet,
+     * oldest first, each with the turns still to end before its own has. Several
+     * can be pending: a command's switch is first reported by the next turn's
+     * `init`, which can be another `/model`'s.
+     */
+    private modelCommands;
     protected spawnSpec(opts: AgentStartOptions, workspace: Record<string, string>): SpawnSpec;
+    sessionCost(): RunnerSessionCost | null;
+    /** A count kept for another session says nothing of this one's. */
+    private countFrom;
     savedOutput(abs: string): boolean;
     /**
      * A task's run: the manifest decides what its mode and effort mean
@@ -2937,6 +1971,12 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     dispose(): void;
     private clearFollowOnTimer;
     protected turnPayload(message: string): string;
+    /**
+     * The CLI runs a message that starts with a slash command as that command,
+     * whether the surface sent it as one or as plain text, so the message
+     * itself says a model switch was asked for: every way into the chat counts.
+     */
+    private noteModelCommand;
     private openTurnState;
     /**
      * The echo of a steered message: the model has it. After a closed turn it
@@ -2945,6 +1985,29 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
      */
     private steerDelivered;
     protected handleLine(line: string, emit: (event: AgentEvent) => void): void;
+    /**
+     * A task's main thread reported the model it answers on. A change is the
+     * user's own switch when a model command went out before it: Ordewell never
+     * passes `--fallback-model`, so nothing else should move it. A change with
+     * no command before it is reported as drift, and the plan does not follow
+     * it. A command whose turn ended with the model unchanged switched nothing,
+     * and is let go.
+     *
+     * Effort is never reported (recorded on 2.1.302, `task-effort-command`):
+     * `init` names the model alone, its `per_turn_effort_active` says effort is
+     * on, not which; `/effort low` only prints that it set it; and `/model`
+     * takes no effort (`/model haiku high` is "not found"). So a switch carries
+     * no effort and the plan's stays as planned.
+     */
+    private followModel;
+    /** Whether the model value `asked` runs as the id `resolved`, by what `initialize` lists. */
+    private runsAs;
+    /**
+     * The value `initialize` lists for the id a model runs as. Several can share
+     * one (`sonnet`, `default`); the one asked for wins, and `default` only as a
+     * last resort, since it names whatever the CLI's default becomes.
+     */
+    private listedModel;
     /**
      * `--permission-mode auto` on a model or account without auto mode is not
      * refused: the CLI says nothing and starts in `default`, then asks about every
@@ -2974,6 +2037,13 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
      * complete usage instead.
      */
     private finishForegroundSubagent;
+    /**
+     * The id of the next block an `assistant` line carries, `<message>:<index>`.
+     * The CLI sends a message as one line per content block, in order, so a
+     * block's place among its message's lines is the `index` its stream events
+     * carry (checked against every recorded transcript).
+     */
+    private blockId;
     /**
      * Partial output of the planner's own message. The complete `assistant` line
      * for each block follows its deltas and is authoritative for that block (see
@@ -2984,7 +2054,8 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
      * What only the result line knows: the cost, which covers every call the
      * session made — subagents included, since none of their lines carries one —
      * and the planner model's window. `total_cost_usd` is a running total, so a
-     * turn reports its growth. The first turn after a resume only sets the
+     * turn reports its growth. After a resume it grows from what was counted of
+     * the session before; with no count kept, the first turn only sets the
      * baseline: its total includes turns counted before, and a turn's own share
      * cannot be told apart from them.
      */
@@ -3017,12 +2088,17 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
     private threadModel;
     private readonly rpc;
     private startOpts;
-    /** Whether this turn has already emitted prose — see the `agentMessage` case. */
-    private turnHasText;
+    /** The planner thread's runs of reply text this turn, each under its `agentMessage` item's id. */
+    private replyRuns;
     /** The turn in flight. `turn/interrupt` and `turn/steer` cannot be sent before it has an id. */
     private turn;
     /** The last turn this adapter ended — so its second end signal, landing late, ends nothing. */
     private endedTurnId;
+    /**
+     * The account's limit windows as Codex last reported them. Only read when a
+     * turn fails on the usage limit; an update on its own acts on nothing.
+     */
+    private rateLimits;
     /** An interrupt was asked for during this turn, so however it ends, it was cut short. */
     private interruptRequested;
     /**
@@ -3116,6 +2192,7 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
     /** `turn/start`'s answer. One for a turn that has since closed or been replaced names and closes nothing. */
     private turnAnswered;
     protected handleLine(line: string, emit: (event: AgentEvent) => void): void;
+    private turnFailed;
     private turnStarted;
     /**
      * Ahead of the event that ends the turn: a steer Codex accepted and the turn
@@ -3339,9 +2416,10 @@ declare class OpenCodeAdapter implements TaskModeAgentAdapter {
     private dropUnreadSteers;
     /**
      * Whatever of the turn's own messages the stream missed. Each part is
-     * emitted once, so a turn the stream saw whole adds nothing here; one that
-     * lost its last text part still reaches the plain-text channel, which a
-     * summary falls back to.
+     * emitted once, so a turn the stream saw whole adds nothing here; a text
+     * part whose completion was lost completes as the run its deltas streamed
+     * under, its part's id; one that lost every frame still reaches the
+     * plain-text channel, which a summary falls back to.
      */
     private readBack;
     /**
@@ -3363,7 +2441,7 @@ declare class OpenCodeAdapter implements TaskModeAgentAdapter {
      */
     interrupt(timeoutMs: number): Promise<boolean>;
     onProcessExit(listener: (code: number, lastWords?: string) => void): void;
-    answerPermission(id: string, decision: ApprovalDecision): boolean;
+    answerPermission(id: string, decision: ApprovalDecision): boolean | Promise<boolean>;
     /**
      * OpenCode 2.x replaced the 1.x HTTP surface rather than extending it, and
      * only 2.x answers `/api/info` with its version. A 1.x server — or one that
@@ -3466,17 +2544,48 @@ declare function mapAgentTool(name: string): MappedTool;
  */
 declare function normalizeAgentArgs(tool: ResearchToolType, args: Record<string, unknown>): Record<string, unknown>;
 
-/** What a runner offers a task: the models discovered for it and the modes its manifest declares. */
-interface RunnerCatalog {
-    models: DiscoveredModel[];
-    modes: RunnerModeInfo[];
-    /**
-     * The mode a task lands on when it carries none this runner offers: the
-     * manifest's `autonomous`/`safe`-tagged mode under the user's toggle
-     * (ADR-0001). Absent, `modes[0]` stands in — which for Codex is its
-     * workspace-write sandbox, not the full access an unattended run needs.
-     */
-    defaultMode?: string;
+interface PlannerBackendOptions {
+    /** The planner provider configured now. */
+    provider(): PlannerBackendId;
+    /** A backend for the provider configured now. */
+    create(): IAiService;
+    /** Whether a planner turn is running on the backend. */
+    busy(): boolean;
+}
+/**
+ * The planner transport for the provider configured *right now* (ADR-0009),
+ * and the one place it is let go.
+ *
+ * Resolved on every read rather than once at construction, because a Session
+ * outlives the choice: VS Code hosts exactly one for the whole window, and the
+ * webview pills and `/planner` switch backends underneath it. A service
+ * captured at construction kept the old backend and was handed the new one's
+ * model — an OpenCode model id spawned as `claude --model opencode/…`.
+ *
+ * Letting a backend go — a switch to another provider, or settings that its
+ * client was built from — waits until no planner turn is running on it:
+ * `reset()` cuts the call in flight off, and the turn would end with neither an
+ * answer nor its inputs. A model or effort change needs no reset: a turn on a
+ * live context that no longer matches the configuration replays instead
+ * (`conversationMatchesConfig`). A harness planner holds an OS process, so a
+ * backend replaced is always reset, never just dropped.
+ */
+declare class PlannerBackend {
+    private readonly options;
+    private live;
+    private liveProvider;
+    /** Settings it was built from changed while a turn ran on it. */
+    private stale;
+    /** `pinned`: a backend injected whole, which is reset but never replaced. */
+    constructor(options: PlannerBackendOptions | {
+        pinned: IAiService;
+        busy(): boolean;
+    });
+    current(): IAiService;
+    /** What the backend was built from changed: it is reset now, or as soon as the turn running on it ends. */
+    settingsChanged(): void;
+    /** Make the switch or the reset that waited, if one did. Call while no turn runs: as one is about to take the conversation, and as one lets it go. */
+    settle(): void;
 }
 
 type ModelsByRunner = Partial<Record<RunnerId, DiscoveredModel[]>>;
@@ -3491,6 +2600,8 @@ interface SessionCatalogDeps {
     };
     /** The runners of the plan being edited; empty while the session has none. */
     planRunners: () => RunnerId[];
+    /** Whether a task's runner is up: an attempt claimed, running, quiet or waiting on someone. */
+    liveRunner?: (taskId: string) => boolean;
 }
 /**
  * What a session may assign: the enabled runners, their modes, the models
@@ -3508,14 +2619,16 @@ declare class SessionCatalog {
     constructor(deps: SessionCatalogDeps);
     /** The runners enabled right now. */
     enabledRunners(): RunnerId[];
+    /** The runners `writer` may put a task on now ({@link assignableRunners}); undefined means any. */
+    runnersFor(writer: AssignmentWriter): RunnerId[] | undefined;
     /**
      * The allowlist in force right now. Unset means no restriction — falling
      * back to the one planning started under would keep a restriction the user
      * has since cleared.
      */
     allowlist(): Record<string, string[]>;
-    /** The models the user allows on one runner; unset means no restriction. */
-    allowlistFor(runner: RunnerId): string[] | undefined;
+    /** The enabled runners and allowlist together, for whoever compares an assignment with them. */
+    scope(): AssignmentScope;
     /**
      * The discovered catalog as the resolver holds it now, per runner, with this
      * session's own discovery as the fallback where the resolver has nothing
@@ -3544,18 +2657,29 @@ declare class SessionCatalog {
      * asked for.
      */
     live(): Promise<TaskQueryCatalog>;
+    /**
+     * What {@link live} answers, from what is cached and without discovering:
+     * the enabled runners, however the plan was started. The per-turn block
+     * reads this, so it can never offer a different set than `list_runners`.
+     */
+    current(): TaskQueryCatalog;
     queryCatalog(runners: RunnerId[]): TaskQueryCatalog;
     /**
-     * The catalog a model/task-mode edit is checked against — the same
-     * discovered models and manifest modes the per-turn catalog block shows the
-     * planner, so a refusal here can never name something invalid that the
-     * planner was never told about. The catalog is not filtered by the
-     * allowlist here — `checkModelAndModeValidity` narrows by allowlist itself,
-     * the same way `coerceAssignments` does.
+     * The catalog an assignment is resolved against — the same discovered
+     * models and manifest modes the per-turn catalog block shows the planner,
+     * so a refusal can never name something invalid that the planner was never
+     * told about. The models are not filtered by the allowlist here: the
+     * resolver reads the allowlist itself (`resolveAssignment`).
+     */
+    edit(runners?: RunnerId[]): AssignmentCatalog & {
+        runnerModes: Record<RunnerId, RunnerModeInfo[]>;
+    };
+    /**
+     * What a runner offers a task moved to it or added on it. Spawns the
+     * runner's CLI to list models; null for a runner no manifest declares,
+     * which has no CLI to ask.
      */
-    edit(runners?: RunnerId[]): EditCatalog;
-    /** What a runner offers, as `runnerAssignment` needs it. Spawns the runner's CLI to list models. */
-    runner(runner: RunnerId): Promise<RunnerCatalog>;
+    runner(runner: RunnerId): Promise<RunnerCatalog | null>;
     /**
      * The one place planning discovers what it may draw from: the runners'
      * models and their modes. `filteredModels` is the allowlisted view a prompt
@@ -3569,6 +2693,13 @@ declare class SessionCatalog {
     }>;
 }
 
+/**
+ * A model's context window from a catalog Ordewell already holds — a runner's
+ * own model listing or a provider's own models endpoint, never a table kept in
+ * Ordewell. `source` is the record's reporter: a runner id or a vendor id.
+ */
+type CatalogWindow = (source: string, model: string) => number | undefined;
+
 /** The `planner_usage` member of the session broadcast union. */
 type PlannerUsageMessage = Extract<SessionMessage, {
     type: 'planner_usage';
@@ -3583,7 +2714,11 @@ type PlannerUsageMessage = Extract<SessionMessage, {
  * defined — this module just holds the state and the broadcast shape.
  */
 declare class PlannerUsageLedger {
+    private readonly catalogWindow;
     private usage;
+    private windows;
+    /** `catalogWindow` serves the window of a planner model whose backend reports none. */
+    constructor(catalogWindow?: CatalogWindow);
     /** Fold one model call's record into the totals; returns the running ledger. */
     record(record: UsageRecord): PlannerUsage;
     /** Adopt a persisted ledger (a reopened session) or start from zero. */
@@ -3621,14 +2756,17 @@ interface SessionEventRelayDeps {
  * observers. A wait on a usage limit, and a task gone idle, reach surfaces as
  * the task's status; `onUsageLimitWait` and `onTaskIdle` themselves are for
  * the supervisor to wake on. The end-of-run handoff is marked by supervision
- * and remembered for a surface joining late, so Session announces it too.
+ * and remembered for a surface joining late, so Session announces it too. A
+ * model switch is a plan edit, which Session's editor announces as one.
  */
-type RelayObserver = Required<Omit<OrchestratorObserver, 'onTaskSettled' | 'onRunStarted' | 'onAutoMerge' | 'onUsageLimitWait' | 'onTaskIdle' | 'onIsolationHandoff'>>;
+type RelayObserver = Required<Omit<OrchestratorObserver, 'onTaskSettled' | 'onRunStarted' | 'onAutoMerge' | 'onUsageLimitWait' | 'onModelSwitched' | 'onTaskIdle' | 'onIsolationHandoff' | 'onRunClosed'>>;
 /**
  * Turns orchestrator and planner events into {@link SessionMessage}
  * broadcasts — the one place a surface's view of a Session is produced. It
- * never persists: where an event also owes a save, the Session does that
- * before handing the event on, so no surface sees state the disk lacks.
+ * never persists, and holds nothing of a planner turn: a turn keeps what it
+ * writes until it lands (`PlannerConversation`). Where an event also owes a
+ * save, the Session does that before handing the event on, so no surface sees
+ * state the disk lacks.
  */
 declare class SessionEventRelay {
     private readonly broadcast;
@@ -3640,12 +2778,6 @@ declare class SessionEventRelay {
     private readonly awaitingApproval;
     private readonly checkpointQuestion;
     private readonly waitsForApproval;
-    /**
-     * The in-flight turn's subagent activity, grouped one run per subagent so a
-     * replay nests each step under its own brief/result. Folded into the plan's
-     * researchLog at persist — see {@link flushSubagentRuns}.
-     */
-    private pendingSubagents;
     private statusHeld;
     private statusOwed;
     /** The planner's requests announced and not yet settled, as they were announced: a surface joining now is owed them. */
@@ -3678,20 +2810,6 @@ declare class SessionEventRelay {
     /** `turnId`: the planner turn whose commit this is, when one is. */
     planGenerated(plan: LegacyPlanState | null, goal: string, turnId?: string): void;
     progress(progress: ResearchProgress): void;
-    /** The run for `subagentId`, created on first sighting so a step arriving
-     * before (or without) its started event still gets a home. */
-    private subagentRun;
-    /**
-     * Fold the turn's subagent runs into the plan's researchLog as one contiguous
-     * group per subagent — its entry then its steps, in the order they started —
-     * so a replay nests each step under its own subagent however the live stream
-     * interleaved. A harness planner already logs its child steps through the
-     * turn's researchLog; they are pulled out of that position and re-grouped
-     * rather than duplicated.
-     */
-    flushSubagentRuns(plan: LegacyPlanState): void;
-    /** Forget a turn's subagent runs that will never be persisted. */
-    dropSubagentRuns(): void;
 }
 
 /** Which session's logs, in which workspace. */
@@ -3707,11 +2825,12 @@ interface TaskLogFile {
 /** The attempts a task has a log for, oldest first. */
 declare function listTaskLogAttempts(location: TaskLogLocation, taskId: string): number[];
 /**
- * Start the next attempt's file. Numbered from what is on disk rather than
- * from the orchestrator's count, which restarts at one whenever a plan is
- * loaded and would overwrite the attempts before it.
+ * Start an attempt's file, under the attempt's own number so its log and its
+ * usage ledger name the same attempt. Without one, or when that file already
+ * exists, it takes the next number after what is on disk: nothing saved is
+ * ever overwritten.
  */
-declare function openTaskLog(location: TaskLogLocation, taskId: string): TaskLogFile;
+declare function openTaskLog(location: TaskLogLocation, taskId: string, attempt?: number): TaskLogFile;
 /**
  * One attempt's events, in order; empty when it has no log. A line that does
  * not parse is skipped — the last one, most likely, cut off by a crash
@@ -3719,6 +2838,42 @@ declare function openTaskLog(location: TaskLogLocation, taskId: string): TaskLog
  */
 declare function readTaskLog(location: TaskLogLocation, taskId: string, attempt: number): TaskLogEvent[];
 
+interface TaskLogRecorderDeps {
+    broadcast: SessionBroadcaster;
+    /** Where the session's logs go, read as each attempt starts: a session's id can change between plans. */
+    location: () => TaskLogLocation;
+    /** Opens an attempt's file, under the attempt's number when the spawn named one; tests pass one that never touches the disk. */
+    open?: (location: TaskLogLocation, taskId: string, attempt?: number) => TaskLogFile;
+    flushMs?: number;
+    logger?: ILogger;
+}
+/**
+ * Keeps each structured task's log (ADR-0018, P1): every event of an attempt
+ * is appended to that attempt's file and broadcast as `task_log`, in the same
+ * batches, so what a surface saw live and what it reloads are one sequence.
+ *
+ * It sits around the runner rather than inside the orchestrator, which stays
+ * unaware of logs.
+ */
+declare class TaskLogRecorder {
+    private readonly deps;
+    private readonly open;
+    private readonly flushMs;
+    private readonly logger;
+    /** Each task's latest attempt, by the session it records: its log takes a {@link note} until the next attempt starts. */
+    private readonly latest;
+    constructor(deps: TaskLogRecorderDeps);
+    wrap(runner: IRunner): IRunner;
+    /**
+     * An entry the session did not emit, written into the log of the attempt
+     * that runs `sessionId` and sent at once: what Ordewell made of one of its
+     * events once that settled. Dropped once the task's next attempt started.
+     */
+    note(sessionId: string, taskId: string, entry: TaskLogEvent): void;
+    /** Start a new attempt's log for `session`, opening with the skills it was given, and keep it until the session exits. */
+    record(taskId: string, session: IRunnerSession, skills?: readonly TaskSkillSnapshot[], attemptNumber?: number): void;
+}
+
 /**
  * Options for plan generation. Progress is not overridable: every planner
  * progress event is translated to a SessionMessage inside the Session and
@@ -3803,7 +2958,7 @@ interface SessionDeps {
     /** Persistence seam. Defaults to the saved-session store under the workspace. */
     saveSession?: SaveSession;
     /** Where a structured task's log is saved (ADR-0018, P1). Defaults to a file per attempt beside the session's. */
-    openTaskLog?: (location: TaskLogLocation, taskId: string) => TaskLogFile;
+    openTaskLog?: (location: TaskLogLocation, taskId: string, attempt?: number) => TaskLogFile;
     /** The Ordewell MCP server a harness planner's tools are served from (ADR-0022). Defaults to the process's one. */
     mcpServer?: OrdewellMcpServer;
 }
@@ -3825,7 +2980,7 @@ interface SessionParts {
     modelResolver: ModelResolver;
     settings: () => SessionRuntimeSettings;
     hostSessionId?: string;
-    aiService: () => IAiService;
+    backend: PlannerBackend;
     planner: SessionPlanner;
     store: PlanStore;
     orchestrator: TaskOrchestrator;
@@ -3835,6 +2990,8 @@ interface SessionParts {
     usage: PlannerUsageLedger;
     approvals: PendingApprovals;
     approvalPolicy: ApprovalPolicy;
+    /** Where the Session writes what it made of a task's event into that attempt's log. */
+    taskLogs: Pick<TaskLogRecorder, 'note'>;
     fetcher: IWebFetcher;
     skillsService: Pick<SkillsService, 'findSkill' | 'listSkills' | 'searchedDirs' | 'forRoot'>;
     saveSession: SaveSession;
@@ -3854,7 +3011,7 @@ interface SessionParts {
  * (setModels, setRunnerList, …) stay on the host; Session never emits them.
  */
 declare class Session {
-    private readonly aiService;
+    private readonly backend;
     private readonly usage;
     private readonly events;
     private readonly planner;
@@ -3874,6 +3031,8 @@ declare class Session {
      * supervisor has first.
      */
     private sentHandoff;
+    /** The run was forgotten and no surface has been told yet; see {@link announceClosed}. */
+    private closedUnannounced;
     /** The edit the open planner turn holds, as last announced: a surface that joins mid-turn is shown it. */
     private sentHeld;
     private readonly notifications;
@@ -3882,6 +3041,7 @@ declare class Session {
     private readonly fsAdapter;
     private readonly approvals;
     private readonly approvalPolicy;
+    private readonly taskLogs;
     private readonly fetcher;
     private readonly settingsFn;
     private readonly save;
@@ -3909,8 +3069,6 @@ declare class Session {
     private turnEffects;
     /** Every turn's effects with starts still owed: a turn's may still be running its starts when the next opens. */
     private readonly owingEffects;
-    /** What the planner's next turn is told before anything else; see {@link PlannerConversationHost.takeRunUpdates}. */
-    private readonly untoldRunUpdates;
     private unlistenApprovals;
     private readonly plannerTools;
     constructor(parts: SessionParts);
@@ -3955,9 +3113,9 @@ declare class Session {
     /** The open planner turn is the supervisor's, acting at Act: its edits and added tasks are its own (ADR-0029). */
     private supervisorEditing;
     /**
-     * The runners a planner edit may put a task on: the plan's own, and every
-     * runner enabled now. An edit is checked as it is made and again as it lands
-     * against this one set, so what was accepted cannot be refused at commit.
+     * The runners a planner edit may put a task on (`assignableRunners`). An
+     * edit is checked as it is made and again as it lands against this one set,
+     * so what was accepted cannot be refused at commit.
      */
     private editRunners;
     /**
@@ -3997,7 +3155,6 @@ declare class Session {
      * task under the same id (ADR-0029).
      */
     private keepApprovals;
-    private approveTask;
     /**
      * Answer an outstanding approval. Every surface funnels here — the web
      * server's HTTP route, the VS Code webview, the TUI prompt — so the decision
@@ -4038,9 +3195,9 @@ declare class Session {
      */
     private syncPlanTasks;
     /**
-     * Persists PlanStore state to disk. PlanStore is the single authority.
-     * `background`: an execution event's save, which may land in the middle of a
-     * planner turn without settling it (see {@link PlannerConversation.restore}).
+     * Persists PlanStore state to disk. PlanStore is the single authority. Any
+     * save may come in the middle of a planner turn, and finds nothing of it to
+     * write: a turn holds what it writes until the mutation that lands it.
      */
     private persist;
     /** A new plan on a long-lived Session gets its own persisted identity (unless the host fixed one). */
@@ -4049,8 +3206,8 @@ declare class Session {
      * The plan scope ends: everything that belongs to the plan this Session
      * holds goes, so nothing of it reaches the next one — a new plan, another
      * session adopted, or the Session closed. Its run is stopped, the planner
-     * turn in flight is abandoned with its uncommitted subagent steps, what that
-     * turn deferred is settled, and the conversation, supervision, usage ledger,
+     * turn in flight is abandoned with everything it held, what that turn
+     * deferred is settled, and the conversation, supervision, usage ledger,
      * execution log and planner prompts are cleared. A new plan on the same
      * Session keeps the scopes the user granted (`keepGrants`); a session
      * boundary does not (ADR-0008).
@@ -4081,6 +3238,8 @@ declare class Session {
      * boundary rewrites `in_progress` to `pending` — nothing is running when a
      * session comes off a file — so a surface that re-reads the plan mid-run must
      * come here instead, or every task it is watching reads as never started.
+     * An archived snapshot carries the task as it is now: a retry or continue
+     * keeps the archive while the live task runs on and spends more.
      */
     get currentPlanState(): PlanState | null;
     get currentGoal(): string;
@@ -4192,12 +3351,6 @@ declare class Session {
      */
     compactConversation(signal?: AbortSignal): Promise<ConversationCompaction>;
     rewindTargets(): RewindTarget[];
-    /**
-     * Hand the planner turn in flight a validated plan or a task edit; the turn
-     * commits it as it would the same JSON in the planner's reply. False when
-     * no turn is open.
-     */
-    submitToTurn(submission: PlannerSubmission): boolean;
     /** A plan the planner submitted through its tool, already checked against the live catalog. */
     private submitPlanFromTool;
     /**
@@ -4254,13 +3407,16 @@ declare class Session {
      * level at each call. Other sessions' runs keep theirs until they end.
      */
     applyRunSettings(changes: Partial<GlobalRunSettings>): void;
-    executePlan(): Promise<void>;
     private idlePlan;
     private runWholePlan;
-    approveReview(): Promise<LegacyPlanState>;
-    forceStartTask(taskId: string): Promise<void>;
+    /**
+     * Execute while a run is under way (#95): the seam has approved every task,
+     * as executing does, and the run takes them in. A run the scheduler was not
+     * driving, one task started on its own, becomes the plan's run, as Execute
+     * would make it.
+     */
+    private joinRun;
     private startOneTask;
-    runTask(taskId: string): Promise<void>;
     /**
      * A stale id — a task removed since the surface last drew it — is refused.
      * Reloading the plan to find it never could, and reset the verifier under
@@ -4269,26 +3425,28 @@ declare class Session {
     private requireTask;
     /** Start whatever the scheduler can now fit — after the parallel limit was raised mid-run, say. */
     reschedule(): Promise<void>;
-    retryTask(taskId: string): Promise<void>;
     private restartTask;
+    private resumeTask;
     /**
-     * Continue a finished structured task in its saved runner session with the
-     * user's message (ADR-0018, K1); throws `TaskControlError` for a task that
-     * cannot be continued.
+     * Keep what waits on the planner's usage limit from being sent at the reset:
+     * it goes with the user's next message instead. False when nothing waits on
+     * a reset.
      */
-    continueTask(taskId: string, message: string): Promise<void>;
-    private resumeTask;
-    cancelTask(taskId: string): Promise<void>;
-    markTaskComplete(taskId: string): Promise<void>;
-    markTaskIncomplete(taskId: string): Promise<void>;
-    /** Resume a task paused on a usage limit now, once the user says it has reset; see {@link TaskOrchestrator.resumeNow}. */
-    resumeNow(taskId: string): Promise<void>;
+    cancelPlannerResend(): boolean;
     /** Keep a task paused on a usage limit from resuming on its own; see {@link TaskOrchestrator.cancelScheduledResume}. */
-    cancelScheduledResume(taskId: string): boolean;
+    private cancelScheduledResume;
+    /**
+     * The plan follows a model switch the user made in the runner (#106), and
+     * the task's log says what the plan holds once that settled: a write-back
+     * not made — no model command asked for the change, or the edit failed — is
+     * stated, never shown as made. Once the switch's attempt has ended, the plan
+     * may be another one, so nothing of it is said.
+     */
+    private followRunnerModel;
     /** Said through both channels: a host shows one or the other, never both (the daemon's toasts are no-ops). */
     private notice;
-    approveCheckpoint(taskId: string): void;
-    rejectCheckpoint(taskId: string, reason?: string): void;
+    private approveCheckpoint;
+    private rejectCheckpoint;
     /** Whether an answer would reach the task: it waits at a checkpoint and a runner is left to hear it. */
     awaitsCheckpoint(taskId: string): boolean;
     /**
@@ -4296,20 +3454,21 @@ declare class Session {
      * `TaskControlError` for one that cannot take it. A task waiting for input
      * is back in progress, and saved so before any surface is told.
      */
-    sendTaskMessage(taskId: string, text: string): string;
+    private sendTaskMessage;
     /**
      * Force send (ADR-0023, F1): interrupt the task's running turn and deliver
      * this message next. Throws `TaskControlError` where a plain message would.
      */
-    forceSendTaskMessage(taskId: string, text: string): string;
+    private forceSendTaskMessage;
     /**
-     * The task runner's own command `/name args` (#66), as a turn of its own.
-     * Throws `TaskControlError` where a plain message would.
+     * The task runner's own command `/name args` (#66), as a turn of its own;
+     * not an execution control, so it carries no command at the seam and the
+     * daemon hands it straight to the runner. Throws `TaskControlError` where a
+     * plain message would.
      */
     invokeTaskCommand(taskId: string, name: string, args?: string): string;
-    forceSendQueuedTaskMessage(taskId: string, id: string): boolean;
-    removeQueuedTaskMessage(taskId: string, id: string): boolean;
-    interruptTask(taskId: string): Promise<void>;
+    private forceSendQueuedTaskMessage;
+    private removeQueuedTaskMessage;
     /** Replay a run a dirty tree blocked, after stashing the tracked changes. */
     continueWithStash(): Promise<void>;
     /** Replay a run a dirty tree blocked, in the workspace root, for this run only. */
@@ -4335,13 +3494,20 @@ declare class Session {
     /**
      * "Merge all": each repo's integration branch into whatever the user has
      * checked out there — every repo, or none if any cannot take it. The one
-     * irreversible step of isolated execution. Automatic gate merging and the
-     * supervisor's merge_all share this path. During a run it merges what has
-     * landed so far,
-     * which is what opens a merge gate (ADR-0020); it waits for no ops task,
-     * and refuses while one runs.
+     * irreversible step of isolated execution. The user's Merge all and the
+     * supervisor's merge_all reach it through the seam; automatic gate merging
+     * shares the scheduler's half of it. During a run it merges what has landed
+     * so far, which is what opens a merge gate (ADR-0020); it waits for no ops
+     * task, and refuses while one runs.
+     */
+    private mergeAll;
+    /**
+     * Say so when the isolated run is gone: a merge that left nothing to hand
+     * over clears it up (ADR-0013), and so does a discard. Surfaces fold this
+     * instead of reading the merge result, which cannot tell a merge that ended
+     * the run from one that only opened a gate (ADR-0020).
      */
-    mergeRun(): Promise<IsolationMergeResult>;
+    private announceClosed;
     /** Remove the run's worktrees and task branches; keep its integration branch to review or merge. */
     cleanupRun(): Promise<void>;
     /**
@@ -4368,10 +3534,7 @@ declare class Session {
      * a hold would stall every task's status for as long, and an
      * `execution_complete` the control triggers would overtake the status held
      * back — which a surface treats as the end of the stream. Instead each status
-     * announced while one runs is saved first (see {@link observer}), as the
-     * background save of an execution event: it may land mid planner turn. So
-     * is the last one where the control is itself execution, not the user's
-     * word on the plan (`background`).
+     * announced while one runs is saved first (see {@link observer}).
      */
     private withSave;
     private saveForControl;
@@ -4417,7 +3580,12 @@ declare class Session {
         persist?: boolean;
     }): void;
     destroy(): void;
-    get aiServiceInstance(): IAiService;
+    /**
+     * The planner's settings or credentials changed: its backend is let go and
+     * built afresh from them, once no planner turn is running on it (see
+     * {@link PlannerBackend}).
+     */
+    plannerSettingsChanged(): void;
 }
 
 /**
@@ -4433,341 +3601,6 @@ declare class PlanEditError extends Error {
     constructor(message: string);
 }
 
-/** What the preflight reads: the planner choice and whatever it needs to be reachable. */
-type PlannerReadinessConfig = Pick<IConfig, 'aiProvider' | 'planningModel' | 'openaiCompatibleBaseUrl' | 'getProviderApiKey'>;
-/**
- * Why the selected planner cannot plan yet, as data. Each surface words it with
- * its own command spelling (`describePlannerNotReady`), so a daemon, a chat and
- * a shell script can all say the same thing without sharing a syntax.
- */
-type PlannerNotReady = {
-    code: 'no_key';
-    provider: AiProvider;
-    label: string;
-    keyEnvVar: string;
-} | {
-    code: 'no_base_url';
-    provider: AiProvider;
-    label: string;
-    baseUrlEnvVar: string;
-} | {
-    code: 'no_model';
-    provider: AiProvider;
-    label: string;
-};
-/**
- * What the selected planner still needs before it can plan, or null when it is
- * ready. There are two ways in (ADR-0009), and only one of them involves a
- * credential: a harness planner drives a coding agent already installed on the
- * machine, authenticated by the user's own subscription, so demanding an API
- * key of it turns a working setup into a wall. Its model is optional too: an
- * unset id means "the agent's own default".
- */
-declare function plannerNotReady(config: PlannerReadinessConfig): PlannerNotReady | null;
-/**
- * `plannerNotReady` judged on a host's own config — the one way every host
- * builds the preflight's input, so none can hand it a key the selected
- * planner's transport will not read (a stored OpenRouter key passing for an
- * OpenAI planner, which then failed inside the transport). Every planner turn
- * judges through this too, so none can let through what another refuses.
- */
-declare function plannerNotReadyFor(config: Pick<IConfig, 'aiProvider' | 'orchestratorModel' | 'planningModel' | 'openaiCompatibleBaseUrl' | 'getProviderApiKey'>): PlannerNotReady | null;
-/** How one surface spells the commands a not-ready message points at. */
-interface PlannerCommandSyntax {
-    pickPlanner: string;
-    setKey(provider: AiProvider): string;
-    setModel: string;
-}
-declare const TERMINAL_UI_COMMANDS: PlannerCommandSyntax;
-/** The VS Code chat shares the terminal's slash commands, except that its `/model` needs `set`. */
-declare const CHAT_COMMANDS: PlannerCommandSyntax;
-declare const HEADLESS_CLI_COMMANDS: PlannerCommandSyntax;
-declare function describePlannerNotReady(reason: PlannerNotReady, commands: PlannerCommandSyntax): string;
-/**
- * A planner turn refused before it began. Carries the reason as data so a
- * client that spells commands differently (the headless CLI) can re-word it;
- * the message is the terminal UI's spelling, which is what most clients show.
- */
-declare class PlannerNotReadyError extends Error {
-    readonly reason: PlannerNotReady;
-    constructor(reason: PlannerNotReady);
-}
-
-/** What the user last picked for one planner backend. */
-interface PlannerModelChoice {
-    model: string;
-    effort?: string;
-}
-/**
- * A candidate model as this planner's catalog lists it. Deliberately plain
- * data: a harness planner's catalog is its runner's own model list and a
- * vendor's is a picker list (ADR-0009), and the rule below is the same for
- * both — so the caller normalizes, and this module never reaches for a
- * ModelResolver, a config or the network.
- */
-interface PlannerModelCandidate {
-    id: string;
-    variants?: {
-        id: string;
-    }[];
-}
-interface PlannerModelRecall {
-    model: string;
-    effort: string;
-    source: 'remembered' | 'catalog-default' | 'none';
-}
-/** The slice of `SettingsService` this needs, so tests can pass a plain object. */
-interface PlannerModelStore {
-    getPlannerModel(provider: string): PlannerModelChoice | undefined;
-    setPlannerModel(provider: string, entry: PlannerModelChoice | undefined): void;
-}
-/**
- * Remembers, per planner backend, the model the user last chose for it.
- *
- * Switching the planner has to clear the model — an id is scoped to the agent
- * that listed it, so an OpenRouter slug handed to Claude Code points it at
- * something it cannot spawn. That clear is correct and stays; what was missing
- * is that switching *back* then forced a re-pick of a model the user had
- * already chosen. The rule itself is `selectPlanner`'s; this is the storage
- * the surfaces that keep their memory in the settings file hand it.
- */
-declare class PlannerModelMemory {
-    private store;
-    constructor(store: PlannerModelStore);
-    /** Record what the user picked for `provider`; a blank model forgets it instead. */
-    remember(provider: string, model: string, effort?: string): void;
-    getPlannerModel(provider: string): PlannerModelChoice | undefined;
-    /**
-     * What the model and effort should become when `provider` takes over the
-     * planner, given the models it actually serves. The `source` is what the
-     * three surfaces word their notice from — restored, defaulted, or nothing.
-     */
-    recall(provider: string, catalog: PlannerModelCandidate[]): PlannerModelRecall;
-}
-
-/**
- * The daemon contract: every HTTP body the local daemon sends, in one place.
- *
- * The daemon's routes build their bodies against these types and the CLI's
- * `ApiClient` reads them back, so a field added on one side is a compile error
- * on the other. Before this there were three hand-written copies — the routes'
- * inline `c.json`, the client's per-method generics, and the TUI's slice of the
- * client — and they had drifted (the client declared a `headless` field the
- * daemon never sent, and typed `GET /sessions/:id`'s plan as the wrong shape).
- *
- * Types only. Core is the one package both the daemon and its clients already
- * depend on; importing from the daemon would pull its runtime into the CLI.
- */
-/**
- * Why a request was refused, as a stable code a client switches on instead of
- * reading the message. Absent on a refusal nobody needs to tell apart — a
- * missing field, say — where the message is all there is.
- */
-type DaemonErrorCode = 'session_not_found' | 'task_not_found' | 'no_plan' | 'already_executing' | 'workspace_not_found' | 'workspace_not_a_project' | 'conversation_busy'
-/** The user stopped the planner turn: the turn ended as asked, so a client stays quiet. */
- | 'planner_turn_stopped'
-/** The planner turn settled after its plan was dropped; nothing it produced was kept. */
- | 'planner_turn_discarded'
-/** The selected planner cannot plan yet (no key, no base URL, no model); `plannerNotReady` says which. */
- | 'planner_not_ready'
-/** The request asked for something the plan, task or conversation does not allow. */
- | 'refused' | 'checkpoint_not_waiting' | 'approval_not_outstanding';
-/** The body of every non-2xx answer a route gives. */
-interface ErrorBody {
-    error: string;
-    code?: DaemonErrorCode;
-    /** Set with `workspace_not_a_project`: the directory the daemon refused, so a client can offer to initialize it. */
-    workspace?: string;
-    /** Set with `planner_not_ready`: the reason as data, so a client can word it in its own commands. */
-    plannerNotReady?: PlannerNotReady;
-}
-interface OkResponse {
-    ok: boolean;
-}
-/**
- * A plan as the planner routes return it: the session's plan state, not the
- * `SerializedPlan` a websocket `plan_generated` carries. The two differ —
- * this one holds raw tasks and the dialogue's bookkeeping — and a client that
- * reads either reads only the fields it needs. Skill bodies stay in the
- * session: loads and attempt snapshots arrive as notices.
- */
-interface PlanResponse {
-    plan: SurfacePlan;
-}
-/** `POST /plans/:id/resolve-conflict`: `null` when the session had no conflict to hand a resolver task. */
-interface ResolveConflictResponse {
-    plan: SurfacePlan | null;
-}
-/** What `GET /api/models` returns, and what the pool's provider discovery produces. */
-interface ModelsResponse {
-    models: DiscoveredModel[];
-    modelsByRunner: Record<string, DiscoveredModel[]>;
-    /** Each runner's manifest modes, so a surface can offer a per-task mode picker. */
-    modesByRunner: Record<string, RunnerModeInfo[]>;
-    orchestratorModel: string;
-    providers: AiProvider[];
-    /** Full cross-provider catalog for the orchestrator (planner) model picker. */
-    orchestratorModels: OrchestratorOption[];
-    /** Per-provider catalog-fetch failures, keyed by provider id. */
-    providerErrors: Record<string, string>;
-}
-/** One-shot planning answers in the phase-tagged shape a saved session is read back in. */
-interface GeneratePlanResponse extends Pick<ModelsResponse, 'models' | 'modelsByRunner'> {
-    plan: SurfacePlanState;
-    /** The host notes the plan's transcript records, a skill check's warnings among them, which the phase-tagged plan does not carry. */
-    notes?: string[];
-}
-interface ExecuteResponse {
-    status: 'running';
-}
-interface StopResponse {
-    status: 'stopped';
-}
-interface CancelPlanningResponse {
-    cancelled: boolean;
-}
-/** `POST /api/plans/:id/tasks/:taskId/resume/cancel` — false when no resume was scheduled for the task. */
-interface CancelResumeResponse {
-    cancelled: boolean;
-}
-interface TaskMessageResponse {
-    id: string;
-}
-interface ForceSendResponse {
-    sent: boolean;
-}
-interface RemoveMessageResponse {
-    removed: boolean;
-}
-interface MergeGateEntry {
-    id: string;
-    order: number;
-    title: string;
-}
-interface MergeGateResponse {
-    mergeGate: MergeGateEntry[];
-}
-interface IsolationDiffResponse {
-    diff: string;
-}
-/** A merge that conflicts or is blocked is an outcome, not a refusal, so it answers 200 with the result. */
-type IsolationMergeResponse = IsolationMergeResult;
-/** A fork the daemon has already adopted. */
-interface ConversationForkResponse {
-    sessionId: string;
-    goal: string;
-    plan: SurfacePlan;
-}
-/** A fork made by a rewind, with the full text of the message it was made just before. */
-interface ConversationRewindResponse extends ConversationForkResponse {
-    rewoundMessage: string;
-}
-interface RewindTargetsResponse {
-    targets: RewindTarget[];
-}
-interface ConversationCompactResponse extends ConversationCompaction, PlanResponse {
-}
-interface PrdResponse {
-    prdMarkdown: string;
-}
-interface RunnerEntry {
-    id: string;
-    name: string;
-    enabled: boolean;
-}
-interface RunnersResponse {
-    runners: RunnerEntry[];
-    orchestratorModel: string;
-}
-/** Sessions: a saved one comes off its file, a live one from the pool's store. */
-interface SessionResponse {
-    meta: SessionMeta;
-    plan: SurfacePlanState;
-}
-interface AdoptSessionResponse extends OkResponse {
-    plan: SurfacePlan;
-    goal: string;
-}
-interface TaskLogAttemptsResponse {
-    attempts: number[];
-}
-interface TaskLogResponse {
-    attempt: number;
-    events: TaskLogEvent[];
-}
-type SessionListResponse = SessionMeta[];
-interface SettingsResponse {
-    orchestratorModel: string;
-    /** Who plans (ADR-0009) — a vendor id, or a runner serving as a harness planner. */
-    aiProvider: PlannerBackendId;
-    plannerThinkingEffort: string;
-    maxParallel: number;
-    modelAllowlist: UserSettings['modelAllowlist'];
-    plannerModels: UserSettings['plannerModels'];
-    /** The user's run settings (ADR-0030), each at its default until set. */
-    run: GlobalRunSettings;
-}
-/** What `PATCH /api/settings` answers: the settings as they now stand, plus what the write itself decided. */
-interface SettingsUpdateResponse extends SettingsResponse {
-    /**
-     * Which model a planner switch landed on and why — remembered for that
-     * backend, its catalog default, or none. Present only when the write changed
-     * the planner; absent for every other write, where nothing was recalled.
-     */
-    switchRecall?: PlannerModelRecall;
-    /** Env keys the daemon refused to apply, so a client does not persist what the daemon would not. */
-    rejectedEnvKeys?: string[];
-}
-interface CommandDescriptor {
-    name: string;
-    description: string;
-}
-interface CommandsResponse {
-    commands: CommandDescriptor[];
-}
-interface WorkspacesResponse {
-    workspaces: string[];
-}
-interface ApprovalsResponse {
-    pending: PendingApproval[];
-    approvedScopes: string[];
-}
-interface ApprovalAnswerResponse extends OkResponse {
-    granted: boolean;
-    decision: ApprovalDecision['decision'];
-}
-/**
- * Where a frame stands in its session's broadcast stream. A client holding
- * several sockets on one session gets every broadcast on each, and a frame's
- * content is no identity: two clears of a held edit are the same JSON. `seq`
- * rises by one per broadcast of the session for as long as the daemon runs,
- * whichever Session object holds the id; `stream` names the daemon process,
- * so a restarted daemon's numbering is never compared with the last one's.
- */
-interface StreamStamp {
-    stream: string;
-    seq: number;
-}
-/** A broadcast as the session's socket carries it. Unstamped from a daemon older than the stamp. */
-type SessionFrame = (SessionMessage | SessionNotice) & Partial<StreamStamp>;
-type ApprovalRequestMessage = Extract<SessionMessage, {
-    type: 'approval_request';
-}>;
-/**
- * What a session's socket sends right after `connected`: its run as it stands,
- * so a client that joins mid-run has the run view before the next update —
- * the held edit's preview included — and the planner's approval requests
- * still waiting, which no later frame would announce again. `seq` is the last
- * broadcast it accounts for. Every frame after it is a {@link SessionFrame}.
- */
-interface RunSnapshotFrame extends Partial<StreamStamp> {
-    type: 'run_snapshot';
-    sessionId: string;
-    view: RunView;
-    /** Absent from a daemon older than the field: nothing is known, not "none waiting". */
-    approvals?: ApprovalRequestMessage[];
-}
-
 /**
  * Why a call on a session could not be made. Each is a class rather than a
  * message so the daemon can map it to a status and a stable code in one place,
@@ -4953,7 +3786,7 @@ declare abstract class AbstractRunnerSession implements IRunnerSession {
     abstract nativeSessionId(): string | null;
     abstract commands(): RunnerCommand[];
     abstract invokeCommand(name: string, args?: string): string;
-    abstract answerPermission(id: string, decision: ApprovalDecision): boolean;
+    abstract answerPermission(id: string, decision: ApprovalDecision): boolean | Promise<boolean>;
     abstract onTaskComplete(listener: (report: TaskCompleteArgs) => void): void;
     abstract onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
 }
@@ -5010,11 +3843,14 @@ declare class StructuredSession extends AbstractRunnerSession {
     private readonly text;
     private state;
     private turn;
+    /** A terminal event ends the turn before the adapter releases its send. */
+    private sending;
     private turnCount;
     private queue;
     private messageCount;
     private interrupting;
     private lastSessionId;
+    private lastSessionCost;
     private readonly structuredEmitter;
     private permissionCount;
     /**
@@ -5089,7 +3925,8 @@ declare class StructuredSession extends AbstractRunnerSession {
     removeQueued(id: string): boolean;
     queued(): QueuedTaskMessage[];
     nativeSessionId(): string | null;
-    answerPermission(id: string, decision: ApprovalDecision): boolean;
+    sessionCost(): RunnerSessionCost | null;
+    answerPermission(id: string, decision: ApprovalDecision): boolean | Promise<boolean>;
     /** Every open request goes unanswered once the process that asked is gone. */
     private withdrawPermissions;
     interrupt(): Promise<void>;
@@ -5173,34 +4010,6 @@ type Continuability = {
 declare function continuability(task: Task): Continuability;
 declare function canContinue(task: Task): boolean;
 
-interface TaskLogRecorderDeps {
-    broadcast: SessionBroadcaster;
-    /** Where the session's logs go, read as each attempt starts: a session's id can change between plans. */
-    location: () => TaskLogLocation;
-    /** Opens an attempt's file; tests pass one that never touches the disk. */
-    open?: (location: TaskLogLocation, taskId: string) => TaskLogFile;
-    flushMs?: number;
-    logger?: ILogger;
-}
-/**
- * Keeps each structured task's log (ADR-0018, P1): every event of an attempt
- * is appended to that attempt's file and broadcast as `task_log`, in the same
- * batches, so what a surface saw live and what it reloads are one sequence.
- *
- * It sits around the runner rather than inside the orchestrator, which stays
- * unaware of logs.
- */
-declare class TaskLogRecorder {
-    private readonly deps;
-    private readonly open;
-    private readonly flushMs;
-    private readonly logger;
-    constructor(deps: TaskLogRecorderDeps);
-    wrap(runner: IRunner): IRunner;
-    /** Start a new attempt's log for `session`, opening with the skills it was given, and keep it until the session exits. */
-    record(taskId: string, session: IRunnerSession, skills?: readonly TaskSkillSnapshot[]): void;
-}
-
 declare function stripAnsi(text: string): string;
 
 /**
@@ -5616,4 +4425,4 @@ declare const DEFAULT_MAX_PARALLEL = 5;
  */
 declare function parseMaxParallel(value: unknown): number | null;
 
-export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, type AdoptSessionResponse, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApplyTaskOpsResult, ApprovalAnswer, type ApprovalAnswerResponse, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, ApprovalRequest, type ApprovalRequestMessage, type ApprovalsResponse, type AskOptions, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, type ByPlannerBackend, CHAT_COMMANDS, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CancelPlanningResponse, type CancelResumeResponse, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, CodexSandboxAvailability, type CommandDescriptor, CommandLineTooLongError, type CommandOutcome, type CommandsResponse, type ConfiguredPlanner, type Consent, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompactResponse, type ConversationCompaction, ConversationEditError, type ConversationFork, type ConversationForkResponse, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationRewindResponse, type ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, DEFAULT_WEB_READ_BUDGET, type DaemonErrorCode, type DecideOptions, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ErrorBody, type ExecImpl, ExecutableNotFoundError, type ExecuteResponse, ExecutionActor, type ExecutionCommand, ExecutionCommandName, ExecutionCommands, type ExecutionHost, ExecutionRecord, FindSymbolOptions, type ForceSendResponse, GREP_PCRE_PROBE_ARGS, GeminiService, type GeneratePlanResponse, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, GuardTarget, GuardTrip, HARNESS_PLANNER_REASON, HEADLESS_CLI_COMMANDS, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, type IsolationDiffResponse, IsolationLandedTask, type IsolationMergeResponse, IsolationMergeResult, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, type LiveOutputLookup, LiveTail, LiveTailOptions, type LoopGuard, type MappedTool, type MergeGateEntry, type MergeGateResponse, ModelResolver, type ModelResolverDeps, type ModelsResponse, NoPlanError, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, type OkResponse, OpenAiService, OpenCodeAdapter, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, type PlanRequest, type PlanResponse, PlanState, PlanStatus, PlanStore, Planner, type PlannerBackendEntry, PlannerBackendId, type PlannerChoice, type PlannerCommandSyntax, type PlannerModelCandidate, type PlannerModelChoice, type PlannerModelLookup, PlannerModelMemory, type PlannerModelRecall, type PlannerModelSource, type PlannerModelStore, type PlannerNotReady, PlannerNotReadyError, type PlannerReadinessConfig, type PlannerSelectionChange, type PlannerSelectionCurrent, type PlannerSelectionResult, type PlannerSelectionState, type PlannerSubmission, PlannerToolHandler, PlannerTurnDiscardedError, PlannerTurnStoppedError, type PlannerUsability, PlannerUsage, type PrdBlock, type PrdResponse, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, type RemoveMessageResponse, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolveConflictResponse, type ResolvedChoice, type ResolvedPlanner, type RewindTarget, type RewindTargetsResponse, RunMergeView, type RunSnapshotFrame, RunView, RunnerApprovals, RunnerCommand, RunnerId, RunnerInstallation, RunnerManifest, RunnerModeInfo, RunnerRegistry, type RunnerSpawnOptions, type RunnersResponse, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SUPERVISOR_LEVELS, SYMBOL_LANGUAGES, type SaveSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionFrame, type SessionListResponse, SessionMessage, type SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionResponse, type SessionRuntimeSettings, type SettingsResponse, type SettingsUpdateResponse, SkillInfo, type SkillInvocation, SkillLoad, SkillsService, type SpawnSpec, StartAdmission, StdioAgentAdapter, type StopResponse, type StreamStamp, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, SupervisorLevel, type SupervisorPolicy, SurfacePlan, SurfacePlanState, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TERMINAL_UI_COMMANDS, Task, TaskCompleteArgs, type TaskLogAttemptsResponse, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, type TaskLogResponse, TaskMessageFrom, type TaskMessageResponse, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WebRead, type WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorkspacesResponse, type WorktreeIsolationDeps, abbreviateHome, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexSandboxNotice, configuredProviders, continuability, createAiService, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultEnabledRunners, defaultLogger, definitionPattern, deleteSession, describeMergeResult, describePlannerNotReady, detectInstalledPlanner, discoverGeminiModels, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, findInstalledPlanner, formatSearchOutput, getLatestSession, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, installedPlannerAnswered, installedPlannerDetected, isApiProvider, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlannerBackend, isVendorModelFor, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseSearchHits, parseTaskQueryJson, planDirectLaunch, plannerBackendEntries, plannerMessage, plannerNotReady, plannerNotReadyFor, plannerTranscript, prefixModelId, providerForRunner, readDaemonToken, readTaskLog, recordInstalledPlanner, recordedInstalledPlanner, referencePattern, removedPluginNotice, renderTaskQueryAnswer, resetInstalledPlanner, resolveProviderFromPrefix, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, selectPlanner, sessionDataDir, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, taskQuerySignature, textHasTaskQuery, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writePrivateFile };
+export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApprovalAnswer, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, AssignmentScope, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, type ByPlannerBackend, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CodexAdapter, CodexSandboxAvailability, CommandLineTooLongError, type CommandOutcome, type CommandPayload, type ConfiguredPlanner, type Consent, ConsoleLogger, ContextCollector, type Continuability, ConversationCompaction, type ConversationFork, ConversationRequest, type ConversationRewind, ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecImpl, ExecutableNotFoundError, ExecutionActor, type ExecutionCommand, ExecutionCommandName, ExecutionCommands, type ExecutionHost, ExecutionRecord, FindSymbolOptions, GREP_PCRE_PROBE_ARGS, GeminiService, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, GuardTarget, GuardTrip, HARNESS_PLANNER_REASON, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, IAiService, IApproval, IConfig, IFileSystem, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, IsolationLandedTask, IsolationMergeResult, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LiveTail, LiveTailOptions, type LoopGuard, type MappedTool, type MergeWordingHandoff, ModelResolver, type ModelResolverDeps, NoPlanError, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OpenAiService, OpenCodeAdapter, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, PendingApproval, PendingApprovals, PlanEditError, PlanIsolation, type PlanRequest, PlanState, PlanStore, Planner, type PlannerBackendEntry, PlannerBackendId, type PlannerChoice, PlannerModelCandidate, type PlannerModelLookup, PlannerModelRecall, type PlannerModelSource, PlannerModelStore, type PlannerSelectionChange, type PlannerSelectionCurrent, type PlannerSelectionResult, type PlannerSelectionState, PlannerToolHandler, type PlannerUsability, PlannerUsage, type PrdBlock, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolvedChoice, type ResolvedPlanner, RewindTarget, RunMergeView, RunView, RunnerApprovals, RunnerCommand, RunnerId, RunnerInstallation, RunnerManifest, RunnerModeInfo, RunnerRegistry, RunnerSessionCost, type RunnerSpawnOptions, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SUPERVISOR_LEVELS, SYMBOL_LANGUAGES, type SaveSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionDeps, SessionMessage, SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, SkillsService, type SpawnSpec, StartAdmission, StdioAgentAdapter, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, SupervisorLevel, type SupervisorPolicy, Task, TaskCompleteArgs, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, TaskMessageFrom, TaskModeAgentAdapter, TaskOrchestrator, TaskOutputSource, TaskQueryCatalog, TaskRunnerFlags, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, WebRead, WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, checkoutRule, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexSandboxNotice, configuredProviders, continuability, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultEnabledRunners, defaultLogger, definitionPattern, deleteSession, describeMergeResult, detectInstalledPlanner, discoverGeminiModels, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, findInstalledPlanner, formatSearchOutput, getLatestSession, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, installedPlannerAnswered, installedPlannerDetected, isApiProvider, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlannerBackend, isRepoGroup, isVendorModelFor, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, mapAgentTool, mergeTarget, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseSearchHits, planDirectLaunch, plannerBackendEntries, prefixModelId, providerForRunner, readDaemonToken, readTaskLog, recordInstalledPlanner, recordedInstalledPlanner, referencePattern, removedPluginNotice, reposWithWork, resetInstalledPlanner, resolveProviderFromPrefix, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, selectPlanner, sessionDataDir, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writePrivateFile };