@ordewell/core 0.7.1 → 0.7.2

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { a$ as RunnerId, ax as PlanStatus, ab as LegacyPlanState, L as IApproval, k as ApprovalDecision, p as ApprovalRequest, j as ApprovalAnswer, O as ITerminalRunner, M as IConfig, h as AiProvider, aM as ProviderModelLists, m as ApprovalMode, _ as IsolationMergeResult, W as IsolationLandedTask, Q as IWorktreeIsolation, a7 as IsolationTaskStatus, au as PlanIsolation, b4 as RunnerTransport, aU as RepoGroupLayout, P as ITerminalSession, y as DiscoveredModel, bh as Task, f as AgentProcessDeps, c as AgentAdapter, ar as OrdewellMcpServer, aW as ResearchProgress, aV as ResearchLogEntry, w as ConversationMessage, aA as PlannerToolHandler, bE as UsageRecord, bt as TaskSnapshot, r as AwaitingReason, T as IsolationHandoff, a3 as IsolationRun, a4 as IsolationTaskRecord, bj as TaskIsolation, a8 as IsolationView, $ as IsolationOutcome, aT as RepairEvidence, bC as TreeSnapshot, bL as Verdict, b2 as RunnerRegistry, aR as QueuedTaskMessage, aQ as QueuedMessage, b as ActiveTaskSession, aq as OrchestratorOption, bm as TaskModeAgentAdapter, g as AgentStartOptions, e as AgentEvent, aZ as ResearchToolType, aB as PlannerUsage, n as ApprovalPolicy, aw as PlanState, bi as TaskCompleteArgs, t as CheckpointAnswer, b0 as RunnerInvocation, A as AbstractRunner, a as AbstractTerminalSession, b5 as RunnerVersionProbe, ba as StructuredSessionCapability, bu as TaskStartOptions, bw as TaskTokenScope, bb as StructuredTurnEnd, b9 as StructuredEvent, b3 as RunnerSpawnOptions, N as IPluginStore, b1 as RunnerPluginManifest, a_ as ResolveContext, bs as TaskRunnerFlags } from './Task-BnLxkVQF.js';
-export { d as AgentAdapterFactory, i as AllProviderModels, l as ApprovalKind, o as ApprovalPolicyOptions, q as ApprovalSource, B as BlockingPrompt, C as CMD_EXE_MAX_COMMAND_LINE, s as CatalogModel, u as CheckpointArgs, v as CommandLineTooLongError, D as DENY_ALL, x as DiscoveredMode, z as DiscoveryCommand, E as EditPlanArgs, F as EmbeddedNewlineError, G as ExecutableNotFoundError, H as FetchAllProviderModelsOptions, I as HeadlessRunner, J as HeadlessRunnerDeps, K as HeadlessSession, R as IntegrationDisposal, S as IsolationAvailability, U as IsolationHandoffRepo, V as IsolationInactiveReason, X as IsolationLanding, Y as IsolationMergeBlock, Z as IsolationMergeBlockReason, a0 as IsolationPruneResult, a1 as IsolationRemoval, a2 as IsolationRepo, a5 as IsolationTaskRef, a6 as IsolationTaskRepo, a9 as LaunchDeps, aa as LaunchPlan, ac as LineBuffer, ad as ListModelsArgs, ae as ListRunnersArgs, af as McpClientConfig, ag as McpCredential, ah as McpTool, ai as McpToolContext, aj as McpToolReply, ak as Message, al as ModelCatalog, am as ModelShortcut, an as ORCHESTRATOR_SHORTCUTS, ao as ORDEWELL_MCP_PATH, ap as ORDEWELL_MCP_SERVER_NAME, as as OwnerOnlyFile, at as PLANNER_TOOLS, av as PlanModificationWarnings, ay as PlannerStartOptions, az as PlannerTokenScope, aC as PluginCloneFn, aD as PluginEntry, aE as PluginFeatures, aF as PluginMode, aG as PluginModelDiscovery, aH as PluginRunnerDef, aI as PreparedLaunch, aJ as PreparedTask, aK as PreservedWork, aL as ProviderCredentialSource, aN as ProviderModelsResult, aO as PtySize, aP as PtyWrapOptions, aS as RefusedRemoval, aX as ResearchStep, aY as ResearchStepOutcome, b6 as StreamEvent, b7 as StreamStepEvent, b8 as StreamThinkingEvent, bc as SubagentLogEntry, bd as SubagentOutcome, be as SubmitPlanArgs, bf as TASK_COMPLETE_TOOL, bg as TASK_TOOLS, bk as TaskIsolationState, bl as TaskMode, bn as TaskModeUnsupportedError, bo as TaskModelAssignment, bp as TaskOutputArgs, bq as TaskOutputSummary, br as TaskQueryArgs, bv as TaskStatus, bx as TaskToolHandler, by as TaskTransport, bz as TaskType, bA as TaskWithParent, bB as ThinkingBlock, bD as UsageLine, bF as UsageTotals, bG as UserPromptEntry, bH as UserStep, bI as ValidationCheck, bJ as ValidationContext, bK as ValidationResult, bM as VerificationCheck, bN as WINDOWS_MAX_COMMAND_LINE, bO as addPlannerUsage, bP as addTaskToPlan, bQ as addUsage, bR as approvalScopes, bS as buildShellInvocation, bT as collectProviderCredentials, bU as createEmptyPlan, bV as createTask, bW as emptyWarnings, bX as enabledRunners, bY as fetchAllProviderModels, bZ as flattenTasks, b_ as flattenTasksWithParents, b$ as inheritedOps, c0 as isAwaitingReason, c1 as isExecutableResolved, c2 as isGranted, c3 as isMeasured, c4 as isReservedRunnerName, c5 as isRunnerApproval, c6 as isRunnerTransport, c7 as isStructuredSession, c8 as keepExecutionState, c9 as knownModelId, ca as mcpClientConfig, cb as migrateLegacyPlan, cc as migratePlanState, cd as migrateTask, ce as opsFlag, cf as ownerOnlyConfigFile, cg as partedPromptUsage, ch as planDirectLaunch, ci as planShellLaunch, cj as plannerContextFill, ck as posixShellQuote, cl as removeTaskFromPlan, cm as renumberTasks, cn as resolveModelShortcut, co as resolveProvider, cp as sharedMcpServer, cq as stripAnsi, cr as toApprovalDecision, cs as toOrchestratorOptions, ct as updateTaskInPlan, cu as usageLine, cv as validateModifiedPlan, cw as warningsText, cx as windowsCommandLine, cy as wrapWithPty } from './Task-BnLxkVQF.js';
-import { z as TaskOp, M as MergeGateView, r as SessionBroadcaster, A as ApplyTaskOpsResult, s as SessionMessage, t as SessionNotice, x as TaskLogEvent } from './plan-utils--kQRzSE-.js';
-export { a as ApprovalBlock, b as ApprovalStatus, C as CHECKPOINT_TRUNCATE_LENGTH, c as ConversationInput, d as ConversationView, D as DiffRow, e as DiffRowKind, f as DiffStat, g as DisplayBlock, E as EMPTY_CONVERSATION, h as EMPTY_HOLD, i as EMPTY_TASK_LOG, G as GatedConversation, L as LocalEntry, j as MessageBlock, k as MessageRole, N as NOT_STARTED, l as NO_TURN, m as NewTaskFields, O as OutputPreview, P as PlanBlock, n as PlanMarkerStatus, o as PromptHold, S as SerializedPlan, p as SerializedTask, q as SerializedTaskStatus, u as SubagentBlock, v as SubagentChild, w as SubagentStatus, T as TakenPrompt, y as TaskLogView, B as TaskRef, F as TaskRowAction, H as TaskRowContext, I as TaskRowIsolation, J as TaskRowKind, K as TaskRowPlacement, Q as TaskRowSubject, R as TaskRowView, U as TaskStatusKind, V as ThinkingDisplayBlock, W as ToolBlock, X as ToolHeadline, Y as ToolStatus, Z as TurnGate, _ as UsageBlock, $ as aheadOfDraft, a0 as applyTaskOps, a1 as approvalLabel, a2 as awaitingLabel, a3 as canMergeTasks, a4 as canSetDependencies, a5 as canSplitTask, a6 as capConflictFiles, a7 as classifyOutcome, a8 as coalesceTaskLog, a9 as dependencyCandidates, aa as dependentsNotice, ab as dependentsOf, ac as diffRows, ad as diffStat, ae as diffSummary, af as digestTaskLog, ag as drainNext, ah as executionSummary, ai as followTurn, aj as fromTranscript, ak as hasHiddenDetail, al as holdPrompt, am as isTaskRunning, an as markAction, ao as markRequestFor, ap as namedRepos, aq as newTaskFields, ar as opsEditable, as as outputLines, at as outputPreview, au as parseTaskOpsJson, av as pastGateConfirmation, aw as reduceConversation, ax as reduceTaskLog, ay as replayTaskLog, az as runnerToolSubject, aA as serializePlan, aB as serializeTask, aC as serializeTaskStatus, aD as stopTurn, aE as summarizeToolCall, aF as taskRowActions, aG as taskRowView, aH as taskStartedNotice, aI as taskStatusKind, aJ as textHasTaskOps, aK as titledRefs, aL as toTaskLogEvent, aM as toolHeadline, aN as trimToolOutput, aO as truncateCheckpointSummary, aP as unsendAll, aQ as unsendLatest } from './plan-utils--kQRzSE-.js';
-import { I as IFileSystem, R as ReadFileOpts, T as ToolOutcome, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-DofiRcCo.js';
-export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-DofiRcCo.js';
-import { R as RunnerModeInfo } from './ModeResolver-DkMYf4uS.js';
-export { M as ManifestLookup, a as autonomyLevelLabel, b as buildModeGuide, f as filteredBuildModes, p as parseAutonomyLevel, r as resolveDefaultMode, c as resolveTaskMode, d as runnerModesFrom } from './ModeResolver-DkMYf4uS.js';
+import { b0 as RunnerId, ay as PlanStatus, ac as LegacyPlanState, M as IApproval, p as ApprovalRequest, k as ApprovalDecision, j as ApprovalAnswer, P as ITerminalRunner, N as IConfig, h as AiProvider, aN as ProviderModelLists, m as ApprovalMode, $ as IsolationMergeResult, X as IsolationLandedTask, R as IWorktreeIsolation, a8 as IsolationTaskStatus, av as PlanIsolation, b5 as RunnerTransport, aV as RepoGroupLayout, Q as ITerminalSession, z as DiscoveredModel, bi as Task, f as AgentProcessDeps, c as AgentAdapter, as as OrdewellMcpServer, aX as ResearchProgress, aW as ResearchLogEntry, w as ConversationMessage, aB as PlannerToolHandler, bF as UsageRecord, bu as TaskSnapshot, r as AwaitingReason, U as IsolationHandoff, a4 as IsolationRun, a5 as IsolationTaskRecord, bk as TaskIsolation, a9 as IsolationView, a0 as IsolationOutcome, aU as RepairEvidence, bD as TreeSnapshot, bM as Verdict, b3 as RunnerRegistry, aS as QueuedTaskMessage, aR as QueuedMessage, b as ActiveTaskSession, ar as OrchestratorOption, bn as TaskModeAgentAdapter, g as AgentStartOptions, e as AgentEvent, a_ as ResearchToolType, aC as PlannerUsage, n as ApprovalPolicy, ax as PlanState, bj as TaskCompleteArgs, t as CheckpointAnswer, b1 as RunnerInvocation, A as AbstractRunner, a as AbstractTerminalSession, b6 as RunnerVersionProbe, bb as StructuredSessionCapability, bv as TaskStartOptions, bx as TaskTokenScope, bc as StructuredTurnEnd, ba as StructuredEvent, b4 as RunnerSpawnOptions, O as IPluginStore, b2 as RunnerPluginManifest, a$ as ResolveContext, bt as TaskRunnerFlags } from './Task-BpzIbunq.js';
+export { d as AgentAdapterFactory, i as AllProviderModels, l as ApprovalKind, o as ApprovalPolicyOptions, q as ApprovalSource, B as BlockingPrompt, C as CMD_EXE_MAX_COMMAND_LINE, s as CatalogModel, u as CheckpointArgs, v as CommandLineTooLongError, D as DEFAULT_RUNNERS, x as DENY_ALL, y as DiscoveredMode, E as DiscoveryCommand, F as EditPlanArgs, G as EmbeddedNewlineError, H as ExecutableNotFoundError, I as FetchAllProviderModelsOptions, J as HeadlessRunner, K as HeadlessRunnerDeps, L as HeadlessSession, S as IntegrationDisposal, T as IsolationAvailability, V as IsolationHandoffRepo, W as IsolationInactiveReason, Y as IsolationLanding, Z as IsolationMergeBlock, _ as IsolationMergeBlockReason, a1 as IsolationPruneResult, a2 as IsolationRemoval, a3 as IsolationRepo, a6 as IsolationTaskRef, a7 as IsolationTaskRepo, aa as LaunchDeps, ab as LaunchPlan, ad as LineBuffer, ae as ListModelsArgs, af as ListRunnersArgs, ag as McpClientConfig, ah as McpCredential, ai as McpTool, aj as McpToolContext, ak as McpToolReply, al as Message, am as ModelCatalog, an as ModelShortcut, ao as ORCHESTRATOR_SHORTCUTS, ap as ORDEWELL_MCP_PATH, aq as ORDEWELL_MCP_SERVER_NAME, at as OwnerOnlyFile, au as PLANNER_TOOLS, aw as PlanModificationWarnings, az as PlannerStartOptions, aA as PlannerTokenScope, aD as PluginCloneFn, aE as PluginEntry, aF as PluginFeatures, aG as PluginMode, aH as PluginModelDiscovery, aI as PluginRunnerDef, aJ as PreparedLaunch, aK as PreparedTask, aL as PreservedWork, aM as ProviderCredentialSource, aO as ProviderModelsResult, aP as PtySize, aQ as PtyWrapOptions, aT as RefusedRemoval, aY as ResearchStep, aZ as ResearchStepOutcome, b7 as StreamEvent, b8 as StreamStepEvent, b9 as StreamThinkingEvent, bd as SubagentLogEntry, be as SubagentOutcome, bf as SubmitPlanArgs, bg as TASK_COMPLETE_TOOL, bh as TASK_TOOLS, bl as TaskIsolationState, bm as TaskMode, bo as TaskModeUnsupportedError, bp as TaskModelAssignment, bq as TaskOutputArgs, br as TaskOutputSummary, bs as TaskQueryArgs, bw as TaskStatus, by as TaskToolHandler, bz as TaskTransport, bA as TaskType, bB as TaskWithParent, bC as ThinkingBlock, bE as UsageLine, bG as UsageTotals, bH as UserPromptEntry, bI as UserStep, bJ as ValidationCheck, bK as ValidationContext, bL as ValidationResult, bN as VerificationCheck, bO as WINDOWS_MAX_COMMAND_LINE, bP as addPlannerUsage, bQ as addTaskToPlan, bR as addUsage, bS as approvalScopes, bT as buildShellInvocation, bU as collectProviderCredentials, bV as createEmptyPlan, bW as createTask, bX as emptyWarnings, bY as enabledRunners, bZ as fetchAllProviderModels, b_ as flattenTasks, b$ as flattenTasksWithParents, c0 as inheritedOps, c1 as isAwaitingReason, c2 as isExecutableResolved, c3 as isGranted, c4 as isMeasured, c5 as isReservedRunnerName, c6 as isRunnerApproval, c7 as isRunnerTransport, c8 as isStructuredSession, c9 as keepExecutionState, ca as knownModelId, cb as mcpClientConfig, cc as migrateLegacyPlan, cd as migratePlanState, ce as migrateTask, cf as opsFlag, cg as ownerOnlyConfigFile, ch as partedPromptUsage, ci as planDirectLaunch, cj as planShellLaunch, ck as plannerContextFill, cl as posixShellQuote, cm as removeTaskFromPlan, cn as renumberTasks, co as resolveModelShortcut, cp as resolveProvider, cq as sharedMcpServer, cr as stripAnsi, cs as toApprovalDecision, ct as toOrchestratorOptions, cu as updateTaskInPlan, cv as usageLine, cw as validateModifiedPlan, cx as warningsText, cy as windowsCommandLine, cz as wrapWithPty } from './Task-BpzIbunq.js';
+import { B as TaskOp, M as MergeGateView, j as EditCatalog, s as SessionBroadcaster, A as ApplyTaskOpsResult, t as SessionMessage, u as SessionNotice, y as TaskLogEvent } from './plan-utils-D4Z8UyLL.js';
+export { a as ApprovalBlock, b as ApprovalStatus, C as CHECKPOINT_TRUNCATE_LENGTH, c as ConversationInput, d as ConversationView, D as DiffRow, e as DiffRowKind, f as DiffStat, g as DisplayBlock, E as EMPTY_CONVERSATION, h as EMPTY_HOLD, i as EMPTY_TASK_LOG, G as GatedConversation, L as LocalEntry, k as MessageBlock, l as MessageRole, N as NOT_STARTED, m as NO_TURN, n as NewTaskFields, O as OutputPreview, P as PlanBlock, o as PlanMarkerStatus, p as PromptHold, S as SerializedPlan, q as SerializedTask, r as SerializedTaskStatus, v as SubagentBlock, w as SubagentChild, x as SubagentStatus, T as TakenPrompt, z as TaskLogView, F as TaskRef, H as TaskRowAction, I as TaskRowContext, J as TaskRowIsolation, K as TaskRowKind, Q as TaskRowPlacement, R as TaskRowSubject, U as TaskRowView, V as TaskStatusKind, W as ThinkingDisplayBlock, X as ToolBlock, Y as ToolHeadline, Z as ToolStatus, _ as TurnGate, $ as UsageBlock, a0 as aheadOfDraft, a1 as applyTaskOps, a2 as approvalLabel, a3 as awaitingLabel, a4 as canMergeTasks, a5 as canSetDependencies, a6 as canSplitTask, a7 as capConflictFiles, a8 as classifyOutcome, a9 as coalesceTaskLog, aa as dependencyCandidates, ab as dependentsNotice, ac as dependentsOf, ad as diffRows, ae as diffStat, af as diffSummary, ag as digestTaskLog, ah as drainNext, ai as executionSummary, aj as followTurn, ak as fromTranscript, al as hasHiddenDetail, am as holdPrompt, an as isTaskRunning, ao as markAction, ap as markRequestFor, aq as namedRepos, ar as newTaskFields, as as opsEditable, at as outputLines, au as outputPreview, av as parseTaskOpsJson, aw as pastGateConfirmation, ax as reduceConversation, ay as reduceTaskLog, az as replayTaskLog, aA as runnerToolSubject, aB as serializePlan, aC as serializeTask, aD as serializeTaskStatus, aE as stopTurn, aF as summarizeToolCall, aG as taskRowActions, aH as taskRowView, aI as taskStartedNotice, aJ as taskStatusKind, aK as textHasTaskOps, aL as titledRefs, aM as toTaskLogEvent, aN as toolHeadline, aO as trimToolOutput, aP as truncateCheckpointSummary, aQ as unsendAll, aR as unsendLatest } from './plan-utils-D4Z8UyLL.js';
+import { I as IFileSystem, R as ReadFileOpts, T as ToolOutcome, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-CbCmUDBn.js';
+export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-CbCmUDBn.js';
+import { R as RunnerModeInfo } from './ModeResolver-DtfhWeVL.js';
+export { M as ManifestLookup, a as autonomyLevelLabel, b as buildModeGuide, f as filteredBuildModes, p as parseAutonomyLevel, r as resolveDefaultMode, c as resolveTaskMode, d as runnerModesFrom } from './ModeResolver-DtfhWeVL.js';
 import { ChildProcess } from 'child_process';
-import { b as PlanParseError } from './parsing-ddZXZFP4.js';
-export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, c as PlanTaskError, d as PlanTasksResult, T as TASK_OPS_ENVELOPE_KEY, e as TASK_QUERY_ENVELOPE_KEY, f as checkDepsResolve, g as checkImmutableLog, h as checkInProgress, i as checkNoCycles, j as checkUniqueIds, k as escapeControlCharsInStrings, l as extractJsonObject, m as extractObjectWithBalance, n as extractObjectsWithKey, o as looksLikePlanAttempt, p as opensWithJsonObject, q as parsePartialPlan, r as parsePlanJson, s as stripModelNoise, t as stripTrailingCommas, v as validatePlanModification, u as validatePlanTasks } from './parsing-ddZXZFP4.js';
+import { b as PlanParseError } from './parsing-COFGUEWx.js';
+export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, c as PlanTaskError, d as PlanTasksResult, T as TASK_OPS_ENVELOPE_KEY, e as TASK_QUERY_ENVELOPE_KEY, f as checkDepsResolve, g as checkImmutableLog, h as checkInProgress, i as checkNoCycles, j as checkUniqueIds, k as escapeControlCharsInStrings, l as extractJsonObject, m as extractObjectWithBalance, n as extractObjectsWithKey, o as looksLikePlanAttempt, p as opensWithJsonObject, q as parsePartialPlan, r as parsePlanJson, s as stripModelNoise, t as stripTrailingCommas, v as validatePlanModification, u as validatePlanTasks } from './parsing-COFGUEWx.js';
 export { resolveOrderLabel, taskOrderLabel, taskRef, titledTaskRef } from './order-labels.js';
 import 'events';
 import 'zod/v4';
@@ -650,6 +650,7 @@ type GitExecFn = (file: string, args: string[], opts: {
     stdout: string;
     stderr: string;
 }>;
+
 interface WorktreeIsolationDeps {
     config: Pick<IConfig, 'worktreeIsolation' | 'worktreeSetupCommand' | 'workspaceRepos' | 'worktreeLinks'>;
     /** Test seam: every git invocation goes through this. */
@@ -1106,10 +1107,13 @@ interface ConversationRequest {
  * atomically and answers queries out of its own state; the AI service only
  * parses them.
  */
-type ConversationTurn = {
+type ConversationTurn = 
+/** `aborted`: the call was stopped, and `text` is only what it had by then. */
+{
     kind: 'message';
     text: string;
     researchLog: ResearchLogEntry[];
+    aborted?: boolean;
 } | {
     kind: 'plan';
     tasks: Task[];
@@ -1464,15 +1468,6 @@ declare class PlanStore {
     setTaskVerdict(id: string, verdict: Task['verdict']): void;
     setTaskOutputSummary(id: string, summary: Task['outputSummary']): void;
     setTaskTransport(id: string, transport: Task['transport']): void;
-    getPlanVisualization(): {
-        tasks: {
-            id: string;
-            title: string;
-            dependencies: string[];
-            parallelGroups: number[][];
-        }[];
-        parallelGroups: number[][];
-    };
     /**
      * Widen the plan's runner set. Retargeting a task onto a runner the plan has
      * not used before has to land here as well as on the plan state, or
@@ -1552,6 +1547,8 @@ declare class IsolationRunController {
     /** Resolver task id → the conflicted task it resolves; see {@link linkResolver}. */
     private resolvers;
     private opening;
+    /** Bumped by an interrupt, so an activation in flight across it does not open the run it ended. */
+    private activations;
     /** The start a dirty tree turned away, handed back once the user chooses how to go on. */
     private blockedStart;
     /** The dirty repos behind {@link blockedStart}, for the stash notice. */
@@ -1746,6 +1743,10 @@ declare class IsolationRunController {
      * whole. One that cannot be continued for another reason — it ran from a
      * different workspace path — keeps its integration branch in each repo that
      * has not merged it: only the user gives landed work up.
+     *
+     * False when `interrupted` came while git was minting: a newer activation
+     * may be minting its own run, so this one is never installed over it, and
+     * is discarded rather than left as branches no record names.
      */
     private mint;
     private reportCopies;
@@ -1897,7 +1898,7 @@ interface OrchestratorObserver {
     }): void;
     onTick?(): void;
     onExecutionComplete?(): void;
-    /** Queued user messages are ready to be processed by the planner. */
+    /** The run is parked behind queued user messages, with nothing live, until they are drained. */
     onQueueReady?(): void;
     onReviewNeeded?(data: {
         tasks: Task[];
@@ -1951,9 +1952,9 @@ interface TaskAttemptSnapshot {
 }
 /**
  * The wiring a {@link TaskOrchestrator} runs on, every collaborator resolved.
- * {@link createTaskOrchestrator} is the only production caller; tests build one
- * through that factory too. The constructor makes nothing itself, so there is
- * exactly one place defaults live.
+ * {@link TaskOrchestrator.compose} is the only production caller; tests build
+ * one through it too. The constructor makes nothing itself, so there is exactly
+ * one place defaults live.
  */
 interface TaskOrchestratorDeps {
     config: IConfig;
@@ -1978,9 +1979,9 @@ interface TaskOrchestratorDeps {
     previousAttemptFromLog: (taskId: string) => string | null;
 }
 /**
- * What a caller supplies to {@link createTaskOrchestrator}; every optional one
- * gets its default there. This is what a host or test chooses, not the resolved
- * wiring the orchestrator itself runs on.
+ * What a caller supplies to {@link TaskOrchestrator.compose}; every optional
+ * one gets its default there. This is what a host or test chooses, not the
+ * resolved wiring the orchestrator itself runs on.
  */
 interface TaskOrchestratorOptions {
     config: IConfig;
@@ -2151,7 +2152,6 @@ declare class TaskOrchestrator {
     /** Task id → session id of every attempt whose runner is up; a spawn in flight has no session yet. */
     get activeSessionMap(): Map<string, string>;
     getAttempt(taskId: string): TaskAttemptSnapshot | undefined;
-    getAttemptSession(taskId: string): ITerminalSession | undefined;
     get queuedCount(): number;
     /**
      * "Merge all"; a settled run that merged everything is cleared up and
@@ -2183,7 +2183,6 @@ declare class TaskOrchestrator {
     removeQueuedMessage(id: string): boolean;
     setQueuedMessages(messages: QueuedMessage[]): void;
     clearQueuedMessages(): void;
-    processNextQueuedMessage(): QueuedMessage | null;
     loadPlan(tasks: readonly Task[], planRunners?: RunnerId[]): void;
     /**
      * Adopt an edited plan without letting go of the run in progress. Everything
@@ -2224,7 +2223,16 @@ declare class TaskOrchestrator {
      * run up, so neither may happen under a task the plan still shows at work.
      */
     private get settled();
-    onUserTaskComplete(taskId: string): Promise<void>;
+    /**
+     * The boundary a verdict crosses: nothing awaits the verifier's listener, so
+     * a throw from reading the output, landing, releasing a worktree or the tick
+     * after would be an unhandled rejection — and an attempt left integrating is
+     * live work forever. One that never settled fails (a repair waits on the
+     * user, as its conflict did); either way the run halts and says why.
+     */
+    private deliverVerdict;
+    /** Work nothing awaits: a rejection is said, not left unhandled. */
+    private unawaited;
     private onVerdict;
     private afterVerdict;
     /**
@@ -2281,7 +2289,6 @@ declare class TaskOrchestrator {
      */
     releaseTask(taskId: string): Promise<void>;
     markTaskComplete(taskId: string): Promise<void>;
-    markAiTaskComplete(taskId: string): Promise<void>;
     /**
      * Undo a completion: return the task to "not executed" — pending, verdict and
      * summary dropped, archive entry removed. It is put on hold like a cancel, so
@@ -2328,16 +2335,9 @@ declare class TaskOrchestrator {
     isAllComplete(): boolean;
     isAnyFailed(): boolean;
     approveReview(): Promise<void>;
-    getPlanVisualization(): {
-        tasks: {
-            id: string;
-            title: string;
-            dependencies: string[];
-            parallelGroups: number[][];
-        }[];
-        parallelGroups: number[][];
-    };
     tick(): Promise<void>;
+    /** Whether the scheduler may start `id` now: it passes every readiness gate and a slot is free. */
+    private stillReady;
     /**
      * A run paused at merge gates says so, as plainly as a task that waits on
      * the user: which tasks wait, and that Merge all lets them go on (ADR-0020).
@@ -2395,12 +2395,6 @@ declare class TaskOrchestrator {
     private saveNativeSession;
     private endAllAttempts;
 }
-/**
- * Build a {@link TaskOrchestrator}, filling in every collaborator a caller did
- * not inject. The one entry point for hosts, bench harnesses and tests alike;
- * {@link TaskOrchestrator} itself constructs nothing.
- */
-declare function createTaskOrchestrator(options: TaskOrchestratorOptions): TaskOrchestrator;
 
 /**
  * Everything needed to produce a plan from a goal. Carries the planning context
@@ -2641,6 +2635,37 @@ declare function isCliProvider(id: AiProvider): boolean;
 declare function runnerForProvider(id: AiProvider): string | null;
 /** The harness planner that wraps a given runner, or null when none does. */
 declare function providerForRunner(runner: string): AiProvider | null;
+/** One runner's planner usability, as `RunnerInstallation.plannerUsability` reports it. */
+interface PlannerUsability {
+    usable: boolean;
+    reason?: string;
+}
+/**
+ * One entry of the planner backend list (ADR-0009). `id` is the `AiProvider`
+ * either way; `runner` is set only for a harness planner, whose model catalog
+ * comes from that runner, and `reason` is the second line a surface renders —
+ * the block detail for a harness planner, the API-key variable for a vendor.
+ */
+interface PlannerBackendEntry {
+    id: AiProvider;
+    label: string;
+    kind: 'harness' | 'vendor';
+    runner?: string;
+    usable: boolean;
+    reason?: string;
+}
+/** The detail a usable harness planner is always shown with. */
+declare const HARNESS_PLANNER_REASON = "coding agent \u00B7 no API key needed";
+/**
+ * The planner backends every surface offers, in order: the harness planners
+ * first, always listed so a missing CLI is greyed with its reason rather than
+ * hidden, then the configured vendors in `PROVIDER_PRIORITY` order. Pure: the
+ * caller supplies what it knows of each runner (VS Code its `plannerUsability`
+ * results, the TUI its installed set) and maps the entries to its own item
+ * type, keeping surface-specific affordances — e.g. the CLI's empty-vendor
+ * placeholder — to itself.
+ */
+declare function plannerBackendEntries(usability: Readonly<Record<string, PlannerUsability>>, configured: readonly AiProvider[]): PlannerBackendEntry[];
 /**
  * The single definition of which providers count as "configured" — one API
  * key each, or (for `openai_compatible`) an explicit base URL. Every surface
@@ -2740,8 +2765,8 @@ interface SpawnSpec {
  *
  * Subclasses own their agent's protocol: what to spawn, how to phrase a user
  * turn, and how to read one protocol line. Everything below — line framing,
- * turn lifecycle, abort, stderr capture, premature-exit detection — is the
- * same for all of them.
+ * turn lifecycle, abort — is the same for all of them, and the process itself
+ * is a {@link RunnerProcess}.
  */
 declare abstract class StdioAgentAdapter implements AgentAdapter {
     protected deps: AgentProcessDeps;
@@ -2749,8 +2774,7 @@ declare abstract class StdioAgentAdapter implements AgentAdapter {
     protected process: ChildProcess | null;
     protected sessionId: string | null;
     private readonly stdout;
-    private stderrTail;
-    private exited;
+    private readonly runner;
     /** Set for the duration of a turn. Outside one, events are buffered rather than dropped. */
     private turnEmit;
     /** Set for the duration of a turn. Pinged on every raw line, whether or not `handleLine` turns it into an event. */
@@ -2772,11 +2796,6 @@ declare abstract class StdioAgentAdapter implements AgentAdapter {
     /** A task's session, which wants what the agent says on its own after a turn closed; a planner registers none and drops it. */
     private outOfTurnListener;
     private disposed;
-    /** Resolves when the process ends, so a handshake can lose the race instead of waiting out its timeout. */
-    protected processEnded: Promise<void>;
-    /** The environment the agent was spawned under, for any side process a handshake needs. */
-    protected spawnEnv: NodeJS.ProcessEnv;
-    private markEnded;
     /** What this process is to the user — a planner or a task's runner — for the words a failure is reported in. */
     protected role: 'planner' | 'task';
     constructor(deps: AgentProcessDeps);
@@ -2792,6 +2811,17 @@ declare abstract class StdioAgentAdapter implements AgentAdapter {
     /** Protocol handshake, if the agent needs one before it accepts a turn. */
     protected handshake(_opts: AgentStartOptions): Promise<void>;
     start(opts: AgentStartOptions): Promise<void>;
+    /**
+     * Every protocol line goes to `handleLine`, turn or no turn: an agent's
+     * handshake and its session-id announcement both arrive before the first
+     * message is sent, and dropping them left the handshake waiting on a reply
+     * that had already come and gone.
+     */
+    private readProtocol;
+    /** Resolves when the process ends, so a handshake can lose the race instead of waiting out its timeout. */
+    protected get processEnded(): Promise<void>;
+    /** The environment the agent was spawned under, for any side process a handshake needs. */
+    protected get spawnEnv(): NodeJS.ProcessEnv;
     send(message: string, onEvent: (event: AgentEvent) => void, signal?: AbortSignal, onActivity?: () => void): Promise<void>;
     onOutOfTurn(listener: (event: AgentEvent) => void): void;
     nativeSessionId(): string | null;
@@ -2868,7 +2898,6 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     /** The file holding the token lives exactly as long as the process that reads it. */
     private ordewellServerArgs;
     private removeMcpConfig;
-    start(opts: AgentStartOptions): Promise<void>;
     /** Asks the CLI itself, which reports `pending` until its connection attempt settles. */
     mcpAttached(): Promise<boolean>;
     /**
@@ -2974,16 +3003,12 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
     private threadId;
     /** The model Codex opened the thread with — usage records name it. */
     private threadModel;
-    private nextRequestId;
-    private settleHandshake;
-    private handshakeError;
+    private readonly rpc;
     private startOpts;
     /** Whether this turn has already emitted prose — see the `agentMessage` case. */
     private turnHasText;
     /** The turn in flight. `turn/interrupt` and `turn/steer` cannot be sent before it has an id. */
     private turn;
-    /** The JSON-RPC id of the `turn/start` that opened {@link turn}. */
-    private turnRequestId;
     /** The last turn this adapter ended — so its second end signal, landing late, ends nothing. */
     private endedTurnId;
     /** An interrupt was asked for during this turn, so however it ends, it was cut short. */
@@ -2994,8 +3019,6 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
      * that belongs to no turn of the agent's any more (ADR-0023, F4).
      */
     private readonly interruptedTurnIds;
-    /** An interrupt asked for before Codex named the turn, sent once it does. */
-    private interruptOnStart;
     /** A task's approval requests still waiting for an answer, by the request id as a string. */
     private readonly openPermissions;
     /**
@@ -3005,10 +3028,6 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
     private readonly fileChangePaths;
     /** The row each announced file of an in-flight `fileChange` item is shown under, by the file's shown path. */
     private readonly fileChangeRows;
-    /** Requests this adapter sent and awaits an answer to, by JSON-RPC id. */
-    private readonly pendingRequests;
-    private resumeAttempted;
-    private resumeFallbackSent;
     private sandbox;
     /** The Ordewell server's startup state, as Codex last reported it for this thread. */
     private mcpStartup;
@@ -3019,6 +3038,7 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
      * one stream; the thread id is what tells them apart (see {@link subagentOf}).
      */
     private readonly subagents;
+    constructor(deps: AgentProcessDeps);
     protected spawnSpec(opts: AgentStartOptions): SpawnSpec;
     /**
      * `initialize`, then `thread/start`, both before the first user message. A
@@ -3028,16 +3048,18 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
      * construction. A task's runs as its mode says (see {@link threadParams}).
      */
     protected handshake(opts: AgentStartOptions): Promise<void>;
+    private handshakeIncomplete;
     /**
      * Open this session's thread. A resume id means the previous
      * process died mid-session: `thread/resume` puts the agent back in front of
      * the context it already paid to read. A planner's failed resume is not an
-     * error — the response handler falls back to a fresh thread, which is the
-     * same degradation `restoreChat` performs on every surface (T4). A task's
-     * is: Continue (K1) offers the session that did the work, and a fresh thread
-     * in its place would pretend it was resumed.
+     * error — it falls back to a fresh thread, which is the same degradation
+     * `restoreChat` performs on every surface (T4). A task's is: Continue (K1)
+     * offers the session that did the work, and a fresh thread in its place
+     * would pretend it was resumed.
      */
-    private startThread;
+    private openThread;
+    private requestThread;
     private threadParams;
     /**
      * Codex's own startup report for the server, which it sends once the thread
@@ -3048,10 +3070,12 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
     private effort;
     /**
      * `turn/interrupt` names the turn as well as the thread, so an interrupt
-     * asked for before Codex has named the turn waits for it. Codex acknowledges
-     * with an empty result, then ends the turn as `interrupted`.
+     * asked for before Codex has named the turn waits for it, as a steer does.
+     * Codex acknowledges with an empty result, then ends the turn as `interrupted`.
      */
     interrupt(timeoutMs: number): Promise<boolean>;
+    /** Run `send` now if Codex has named the turn, and once it does if not. */
+    private whenNamed;
     /**
      * `turn/steer` into the running turn (ADR-0023). Codex answers with the
      * turn's id at once — acceptance, not delivery — and shows the input to the
@@ -3070,6 +3094,8 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
      */
     answerPermission(id: string, decision: ApprovalDecision): boolean;
     protected turnPayload(message: string): string;
+    /** `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 turnStarted;
     /**
@@ -3148,8 +3174,8 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
  * (ADR-0009, ADR-0018).
  *
  * The odd one out: `opencode serve` is a real server rather than a stdio
- * protocol, so this adapter owns both halves of the boundary — it spawns the
- * process through the same injected `spawn` every other adapter uses, then
+ * protocol, so this adapter owns both halves of the boundary — it starts the
+ * process as the same {@link RunnerProcess} every other adapter uses, then
  * talks to it through the injected `fetch`. Both are part of the one seam the
  * tests drive.
  *
@@ -3169,12 +3195,8 @@ declare class OpenCodeAdapter implements TaskModeAgentAdapter {
     /** Sent on every request to a task's server, which a per-task password secures. */
     private authorization;
     private sessionId;
-    private stderrTail;
-    private exited;
-    private exitCode;
+    private readonly runner;
     private disposed;
-    private markEnded;
-    private readonly processEnded;
     private planner;
     private task;
     /** The last assistant message already settled — the baseline {@link recoverReply} measures a new reply against. */
@@ -3190,7 +3212,19 @@ declare class OpenCodeAdapter implements TaskModeAgentAdapter {
     /** The Ordewell server this process was configured with; null when none was given or its config could not be merged. */
     private ordewell;
     constructor(deps: AgentProcessDeps);
+    private get processEnded();
+    private get exited();
     start(opts: AgentStartOptions): Promise<void>;
+    private launch;
+    /**
+     * Where `serve` listens, or null once it ends or gives up. Stdout only: that
+     * is where `serve` prints its address, and stderr can carry another URL — a
+     * warning about a provider it could not reach. Read a line at a time, and
+     * only until the address is known.
+     */
+    private serverAddress;
+    /** From the server's address to an open session — the 2.x API's, or a 1.x one created or resumed. */
+    private connect;
     send(message: string, onEvent: (event: AgentEvent) => void, signal?: AbortSignal, onActivity?: () => void): Promise<void>;
     /**
      * One task turn. `prompt_async` only queues the work, so the turn is over
@@ -3340,12 +3374,155 @@ 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;
+}
+/**
+ * The model, thinking effort and mode a runner offers for a task.
+ *
+ * A task's model, effort and mode are all scoped to its runner:
+ * `claude-sonnet-4-5` on Codex, or `acceptEdits` on OpenCode, are not degraded
+ * choices but unspawnable ones. So this is where any task acquires a runnable
+ * assignment — a runner change (below) and a hand-added task derive it the same
+ * way. Each field in `current` is preserved when the runner also offers it, and
+ * otherwise snapped to that runner's preferred entry (discovery already sorts
+ * models by the manifest's `preferredPatterns`; the mode is the catalog's
+ * `defaultMode`).
+ *
+ * An empty catalog means discovery failed or the runner is a plugin we have no
+ * list for — not that the runner offers nothing. That field is left out of the
+ * patch and the runner validates last, matching `coerceAssignments`.
+ */
+declare function runnerAssignment(catalog: RunnerCatalog, current?: Pick<Task, 'assignedModel' | 'taskMode'>): Partial<Task>;
+/**
+ * Move a task onto a different runner, carrying its model, thinking effort and
+ * mode over to values that runner actually offers. A runner change is never a
+ * single-field edit — it either brings the other three with it or leaves the
+ * task unrunnable.
+ *
+ * Returns the patch to apply, or `{}` when there is nothing to change.
+ */
+declare function retargetTaskRunner(task: Task, runner: RunnerId, catalog: RunnerCatalog): Partial<Task>;
+
+type ModelsByRunner = Partial<Record<RunnerId, DiscoveredModel[]>>;
+interface SessionCatalogDeps {
+    config: Pick<IConfig, 'enabledRunners' | 'autonomousMode'>;
+    registry: Pick<RunnerRegistry, 'getManifest'>;
+    modelResolver: Pick<ModelResolver, 'modelsForRunners' | 'getCachedRunnerModels'>;
+    /** Read at each call: a toggle or allowlist edit made since the session was built counts (#69). */
+    settings: () => {
+        enabledRunners?: RunnerId[];
+        modelAllowlist?: Record<string, string[]>;
+    };
+    /** The runners of the plan being edited; empty while the session has none. */
+    planRunners: () => RunnerId[];
+}
+/**
+ * What a session may assign: the enabled runners, their modes, the models
+ * discovery found for them and the allowlist narrowing those. Every view of
+ * it — the planner's per-turn block, its tools, a user's direct edit — reads
+ * it here, so none can be shown or checked against something the others are not.
+ *
+ * The discovered models are remembered per runner and only ever merged into:
+ * discovering one runner must not forget another's, since coercion later clamps
+ * thinking efforts against whatever was last found.
+ */
+declare class SessionCatalog {
+    private readonly deps;
+    private discovered;
+    constructor(deps: SessionCatalogDeps);
+    /** The runners enabled right now. */
+    enabledRunners(): RunnerId[];
+    /**
+     * 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 discovered catalog as the resolver holds it now, per runner, with this
+     * session's own discovery as the fallback where the resolver has nothing
+     * cached. The resolver's cache outlives this session's snapshot in both
+     * directions — an allowlist picker re-discovers into it mid-session — and a
+     * model allowed after that must reach the planner with its real label and
+     * variants, not as an id-only stub. Never triggers discovery itself.
+     */
+    models(): ModelsByRunner;
+    /** What this session's own discovery found for a runner; empty when it never ran there. */
+    known(runner: RunnerId): DiscoveredModel[];
+    /** Discover the runners' models, spawning their CLIs where the resolver has none cached, and remember them. */
+    discover(runners: RunnerId[]): Promise<ModelsByRunner>;
+    /**
+     * Keep what an admitted runner was found to offer, for the next coercion's
+     * effort clamping. An empty list is discovery having found nothing, not a
+     * runner offering nothing, so it never displaces what is known.
+     */
+    admit(runner: RunnerId, models: DiscoveredModel[]): void;
+    /** Session boundaries are hard: nothing discovered for one goal informs the next. */
+    reset(): void;
+    modes(runners: RunnerId[]): Record<RunnerId, RunnerModeInfo[]>;
+    /**
+     * What a planner may assign right now: every enabled runner, its modes, and
+     * its allowlisted models. Discovers a runner's models the first time it is
+     * asked for.
+     */
+    live(): Promise<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.
+     */
+    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>;
+    /**
+     * The one place planning discovers what it may draw from: the runners'
+     * models and their modes. `filteredModels` is the allowlisted view a prompt
+     * may show; `modelsByRunner` stays whole because coercion needs real labels
+     * and variants.
+     */
+    planning(runners: RunnerId[]): Promise<{
+        modelsByRunner: Partial<Record<string, DiscoveredModel[]>>;
+        filteredModels: Partial<Record<string, DiscoveredModel[]>>;
+        runnerModes: Record<string, RunnerModeInfo[]>;
+    }>;
+}
+
 /** The dialogue record a fork carries — what {@link PlannerConversation.clone} returns. */
 interface ForkedDialogue {
     conversationHistory: ConversationMessage[];
     researchLog: ResearchLogEntry[];
 }
 
+/**
+ * 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;
+    get signal(): AbortSignal;
+    /** The plan it was answering was dropped under it, so nothing it settles may land. */
+    get abandoned(): boolean;
+    stop(): void;
+    abandon(): void;
+}
 /** 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';
@@ -3386,7 +3563,7 @@ interface PlannerConversationHost {
      * conversation never reaches into execution state directly.
      */
     liveOutput: LiveOutputLookup;
-    hasLiveWork(): boolean;
+    isExecuting(): boolean;
     /** The session's single mutation ritual: op → persist → notify (default: the plan). */
     mutate(op: () => boolean, notify?: () => void): LegacyPlanState | null;
     broadcast: SessionBroadcaster;
@@ -3401,6 +3578,8 @@ interface PlannerConversationHost {
     queueEdit(userMessage: string): number;
     /** Wake a scheduler an applied edit may have unblocked. */
     afterEdit(): Promise<void>;
+    /** The planner turn was stopped or abandoned: whatever it is waiting on (a parked approval) will never be answered. */
+    turnAborted(): void;
 }
 /**
  * A conversation edit (rewind, fork) the conversation refused because the
@@ -3419,6 +3598,25 @@ declare class ConversationEditError extends Error {
 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. */
@@ -3474,13 +3672,32 @@ declare class PlannerConversation {
     private persisted;
     /** Saves an execution event made while a turn may be in flight; see {@link restore}. */
     private savedInBackground;
-    private turnsInFlight;
-    private compacting;
+    private live;
     private openTurn;
     constructor(host: PlannerConversationHost);
     get transcript(): readonly ConversationMessage[];
-    /** Whether a user turn is between its transcript append and its settled outcome. */
+    /** 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(): 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;
+    /**
+     * 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;
     /**
@@ -3589,8 +3806,11 @@ declare class PlannerConversation {
      * inside the host's mutation ritual.
      */
     recordQueuedEditsFailed(messages: string[], reason: string): void;
-    /** Open the conversation on a fresh plan: the goal is its first message. */
-    start(goal: string, opening: ConversationOpening, signal?: AbortSignal): Promise<LegacyPlanState>;
+    /**
+     * 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: string, 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
@@ -3607,7 +3827,20 @@ declare class PlannerConversation {
      */
     private editTouchesLiveWork;
     private assertIdle;
-    private inTurn;
+    /**
+     * 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;
+    /**
+     * 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
@@ -3652,10 +3885,11 @@ declare class PlannerConversation {
      */
     private taskQueryAnswer;
     /**
-     * Drive a planner turn 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.
+     * 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;
     /** Validate + commit a task_ops turn atomically. Returns the errors on rejection (plan untouched). */
@@ -3766,8 +4000,12 @@ interface SessionEventRelayDeps {
     /** What a task's waiting checkpoint asks, whole. */
     checkpointQuestion?: (taskId: string) => string | undefined;
 }
-/** Every orchestrator event the relay announces; `onTaskSettled` is persistence only, so it is the Session's. */
-type RelayObserver = Required<Omit<OrchestratorObserver, 'onTaskSettled'>>;
+/**
+ * Every orchestrator event the relay announces. `onTaskSettled` is persistence
+ * only and `onQueueReady` is the Session's cue to drain its queue, so both are
+ * the Session's alone.
+ */
+type RelayObserver = Required<Omit<OrchestratorObserver, 'onTaskSettled' | 'onQueueReady'>>;
 /**
  * Turns orchestrator and planner events into {@link SessionMessage}
  * broadcasts — the one place a surface's view of a Session is produced. It
@@ -3967,7 +4205,7 @@ declare function createSession(deps: SessionDeps): Session;
 /** What {@link createSession} hands a Session: every collaborator, already built and wired. */
 interface SessionParts {
     config: IConfig;
-    registry: RunnerRegistry;
+    catalog: SessionCatalog;
     workspace: string;
     fsAdapter: IFileSystem;
     broadcast: SessionBroadcaster;
@@ -4012,7 +4250,7 @@ declare class Session {
     private readonly runs;
     private readonly store;
     private readonly config;
-    private readonly registry;
+    private readonly catalog;
     private plan;
     private goal;
     private workspace;
@@ -4025,8 +4263,12 @@ declare class Session {
     private readonly fetcher;
     private readonly settingsFn;
     private readonly save;
-    /** Last discovered model catalog — lets sync plan commits clamp thinking efforts to real variants. */
-    private modelsCache;
+    /** The queue drain in flight, which a second call joins; see {@link processQueuedMessages}. */
+    private queueDrain;
+    /** The queued messages the planner has been given, no longer the user's to take back. */
+    private drainingIds;
+    /** User controls in flight; see {@link withSave}. */
+    private controlsInFlight;
     private unsubObserver;
     private readonly hostSessionId?;
     private currentSessionId;
@@ -4059,7 +4301,7 @@ declare class Session {
     /**
      * The relay announces every orchestrator event; this adds the saves some of
      * them owe, each made before the announcement so no surface sees state the
-     * disk lacks.
+     * disk lacks, and drains the queue the scheduler parked behind.
      */
     private observer;
     /**
@@ -4094,43 +4336,8 @@ declare class Session {
      * session.
      */
     reset(): void;
-    /**
-     * What a planner may assign right now: every enabled runner, its modes, and
-     * its allowlisted models — read as of this call, so a runner enabled or an
-     * allowlist edited since planning started is in it (#69). Discovers a
-     * runner's models the first time it is asked for.
-     */
+    /** What a planner may assign right now; see {@link SessionCatalog.live}. */
     liveCatalog(): Promise<TaskQueryCatalog>;
-    private catalogOf;
-    private runnerModesFor;
-    /**
-     * 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 — {@link checkModelAndModeValidity} narrows by
-     * allowlist itself, the same way `coerceAssignments` does.
-     */
-    private editCatalog;
-    /** The runners enabled right now — a toggle made since the session was built counts (#69). */
-    private enabledRunners;
-    /**
-     * 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.
-     */
-    private allowlist;
-    /**
-     * 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
-     * cached. The resolver's cache outlives this session's snapshot in both
-     * directions — an allowlist picker re-discovers into it mid-session — and a
-     * model allowed after that must reach the planner with its real label and
-     * variants, not as an id-only stub. Never triggers discovery itself.
-     */
-    private models;
-    /** What a runner offers, as `runnerAssignment` needs it. Spawns the runner's CLI to list models. */
-    private catalogFor;
     get planState(): LegacyPlanState | null;
     /**
      * The live plan in the shape a saved session is read back as. The disk
@@ -4146,24 +4353,16 @@ declare class Session {
      * nothing executing, and reporting it as executing is what left the plan
      * unstartable after its last live task was cancelled.
      */
-    get isExecuting(): boolean;
     /** See {@link TaskOrchestrator.hasLiveWork} — a spawned runner, not merely an armed scheduler. */
-    get hasLiveWork(): boolean;
+    get isExecuting(): boolean;
     get status(): 'approved' | 'running' | 'completed';
+    /** Whether a planner turn — a reply, a compaction, plan generation — holds the conversation. */
+    get isPlannerBusy(): boolean;
     /**
-     * Deny every parked approval as soon as a planning turn is aborted, for the
-     * same reason `beginFreshPlan` does it: a prompt raised by a turn nobody is
-     * waiting on has no one left to serve, and denying it unblocks the research
-     * loop instead of stranding it. Without this the request sat out its
-     * five-minute timeout and the loop then carried on as if nothing had
-     * happened — the abort was real, but invisible until long after the user
-     * pressed stop.
-     *
-     * The listener is returned as a disposer rather than left attached: callers
-     * own the signal and may reuse it, and a leaked listener would deny the
-     * *next* turn's prompts the moment that stale signal aborted.
+     * Stop the planner turn in flight. It still settles — a backend hands back
+     * what it had — and ends as stopped. False when no turn is in flight.
      */
-    private denyApprovalsOnAbort;
+    abortPlannerTurn(): boolean;
     generatePlan(goal: string, runners: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
     /**
      * Kick off the planner conversation (ADR-0002): research + the first planner
@@ -4233,13 +4432,6 @@ declare class Session {
      * bare /unknown through to be mis-resolved.
      */
     private resolveSkillInvocation;
-    /**
-     * The one place planning discovers what it may draw from: the runners'
-     * models (cached for later effort clamping), their modes, and the settings
-     * in force. `filteredModels` is the allowlisted view a prompt may show;
-     * `modelsByRunner` stays whole because coercion needs real labels and variants.
-     */
-    private plannerCatalog;
     private conversationOpening;
     /**
      * Load planner-produced tasks, coerced to the allowlist read live — it may
@@ -4276,7 +4468,17 @@ declare class Session {
     cancelTask(taskId: string): Promise<void>;
     markTaskComplete(taskId: string): Promise<void>;
     markTaskIncomplete(taskId: string): Promise<void>;
+    /**
+     * Hand the queued edits to the planner. The Session does this itself each
+     * time the scheduler parks behind the queue, so no surface has to; a caller
+     * only needs it to await the drain. The messages stay queued until the
+     * planner's answer is applied, so the scheduler stays paused behind them
+     * meanwhile; one drain runs at a time, and a call made during it joins it.
+     * Whatever was queued while it ran is drained after, before the run goes on.
+     */
     processQueuedMessages(): Promise<void>;
+    private drainQueue;
+    private applyQueuedEdits;
     /**
      * Every finished task as the log records it: this run's own entries, plus
      * the tasks earlier runs completed, which the log dropped when this run
@@ -4303,7 +4505,7 @@ declare class Session {
     removeQueuedTaskMessage(taskId: string, id: string): boolean;
     interruptTask(taskId: string): Promise<void>;
     getQueuedMessages(): QueuedMessage[];
-    /** Take back one unsent message; the plan's persisted queue follows so a reload cannot resurrect it. */
+    /** Take back one unsent message — false once the planner has it; the plan's persisted queue follows so a reload cannot resurrect it. */
     removeQueuedMessage(id: string): boolean;
     setQueuedMessages(msgs: QueuedMessage[]): void;
     /** Replay a run a dirty tree blocked, after stashing the tracked changes. */
@@ -4343,6 +4545,21 @@ declare class Session {
     /** Add the task that merges a conflicted task's branch by hand; see {@link PlanEditor.addConflictResolver}. */
     resolveConflictAsTask(taskId: string): Promise<LegacyPlanState | null>;
     stopExecution(): void;
+    /**
+     * Run a user control and save what it changed before any surface hears of
+     * it. Not a status hold, as {@link saved} is: these await spawns and git, so
+     * 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`).
+     */
+    private withSave;
+    private saveForControl;
+    /** A control that finishes synchronously: its status is held until it is saved. */
+    private saved;
     /**
      * The one mutation seam: every structural plan mutation runs the same
      * ritual — store op → persist (which snapshots tasks from PlanStore) →
@@ -4399,6 +4616,261 @@ declare class PlanEditError extends Error {
     constructor(message: string);
 }
 
+/** 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. Both surfaces' clears and the restore now read one rule from
+ * here rather than three copies drifting apart.
+ */
+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;
+    /**
+     * 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 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;
+}
+interface OkResponse {
+    ok: boolean;
+}
+/**
+ * A plan as the planner routes return it: the session's plan state itself, 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.
+ */
+interface PlanResponse {
+    plan: LegacyPlanState;
+}
+/** `POST /plans/:id/resolve-conflict`: `null` when the session had no conflict to hand a resolver task. */
+interface ResolveConflictResponse {
+    plan: LegacyPlanState | 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: PlanState;
+}
+interface ExecuteResponse {
+    status: 'running';
+}
+interface StopResponse {
+    status: 'stopped';
+}
+interface CancelPlanningResponse {
+    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: LegacyPlanState;
+}
+/** 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: PlanState;
+}
+interface AdoptSessionResponse extends OkResponse {
+    plan: LegacyPlanState;
+    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 one of the three harness planners. */
+    aiProvider: AiProvider;
+    plannerThinkingEffort: string;
+    maxParallel: number;
+    tdd: UserSettings['tdd'];
+    verification: UserSettings['verification'];
+    modelAllowlist: UserSettings['modelAllowlist'];
+    plannerModels: UserSettings['plannerModels'];
+    runnerTransport: RunnerTransport;
+}
+/** 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 CommandResponse extends OkResponse {
+    settings: SettingsResponse;
+}
+interface WorkspacesResponse {
+    workspaces: string[];
+}
+interface ApprovalsResponse {
+    pending: PendingApproval[];
+    approvedScopes: string[];
+}
+interface ApprovalAnswerResponse extends OkResponse {
+    granted: boolean;
+    decision: ApprovalDecision['decision'];
+}
+
+/**
+ * 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,
+ * and a client can switch on that code instead of reading the wording. Like
+ * `PlanEditError`, none carries a status: core is transport-agnostic.
+ */
+/** No session with that id is held — never planned in this process, or dropped by a restart. */
+declare class SessionNotFoundError extends Error {
+    constructor();
+}
+/** The session holds no plan (or an empty one) for the operation to act on. */
+declare class NoPlanError extends Error {
+    constructor(operation: 'execute' | 'review');
+}
+/** A run is already live, and starting another would reset the one in flight. */
+declare class AlreadyExecutingError extends Error {
+    constructor();
+}
+
 /**
  * Where Ordewell keeps machine-global data (settings, daemon tokens, caches,
  * user plugins). A single home for everything not tied to a project directory,
@@ -4537,6 +5009,8 @@ declare class VerdictEngine {
     markComplete(task: Task): Verdict;
     /** Clear verification state for a task (used on retry). */
     clear(task: Task): void;
+    /** Drop a task's verification state and invalidate any callbacks still holding its generation. */
+    private ceaseTracking;
     /** Drop all tracking state (used on stop / loadPlan). */
     reset(): void;
     private decide;
@@ -4623,45 +5097,6 @@ declare function clampThinkingEffort(effort: string | undefined, variants: {
 }[]): string | undefined;
 declare function coerceAssignments(tasks: readonly Task[], perRunnerAllowlist: Partial<Record<RunnerId, string[]>>, allowedRunners?: RunnerId[], modelsByRunner?: Partial<Record<RunnerId, DiscoveredModel[]>>): Task[];
 
-/** 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;
-}
-/**
- * The model, thinking effort and mode a runner offers for a task.
- *
- * A task's model, effort and mode are all scoped to its runner:
- * `claude-sonnet-4-5` on Codex, or `acceptEdits` on OpenCode, are not degraded
- * choices but unspawnable ones. So this is where any task acquires a runnable
- * assignment — a runner change (below) and a hand-added task derive it the same
- * way. Each field in `current` is preserved when the runner also offers it, and
- * otherwise snapped to that runner's preferred entry (discovery already sorts
- * models by the manifest's `preferredPatterns`; the mode is the catalog's
- * `defaultMode`).
- *
- * An empty catalog means discovery failed or the runner is a plugin we have no
- * list for — not that the runner offers nothing. That field is left out of the
- * patch and the runner validates last, matching `coerceAssignments`.
- */
-declare function runnerAssignment(catalog: RunnerCatalog, current?: Pick<Task, 'assignedModel' | 'taskMode'>): Partial<Task>;
-/**
- * Move a task onto a different runner, carrying its model, thinking effort and
- * mode over to values that runner actually offers. A runner change is never a
- * single-field edit — it either brings the other three with it or leaves the
- * task unrunnable.
- *
- * Returns the patch to apply, or `{}` when there is nothing to change.
- */
-declare function retargetTaskRunner(task: Task, runner: RunnerId, catalog: RunnerCatalog): Partial<Task>;
-
 declare function buildResearchToolsPrompt(): string;
 /**
  * System prompt for one read-only research subagent (issue #34). The digest
@@ -5435,6 +5870,8 @@ interface KillTreeDeps {
         unref?: () => void;
     };
     clearTimeoutImpl?: (handle: unknown) => void;
+    /** Signals a pid, or a process group as its negated id. Injected so the group path needs no real processes. */
+    killImpl?: (pid: number, signal: NodeJS.Signals | 0) => void;
 }
 /**
  * Terminate `proc` and everything it started.
@@ -5664,57 +6101,6 @@ declare function sanitizeSlug(raw: string): string;
 /** Save the PRD to `<workspace>/.scratch/<slug>/PRD.md` (to-prd native convention). */
 declare function savePrdMarkdown(workspace: string, slug: string, markdown: string): string;
 
-/** 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. Both surfaces' clears and the restore now read one rule from
- * here rather than three copies drifting apart.
- */
-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;
-    /**
-     * 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;
-}
-
 /** How many AI tasks may run at once: `ORDEWELL_MAX_PARALLEL`, `/parallel`, `ordewell.maxParallelSessions`. */
 declare const DEFAULT_MAX_PARALLEL = 3;
 /**
@@ -5725,4 +6111,4 @@ declare const DEFAULT_MAX_PARALLEL = 3;
  */
 declare function parseMaxParallel(value: unknown): number | null;
 
-export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, ApplyTaskOpsResult, ApprovalAnswer, ApprovalDecision, ApprovalMode, ApprovalPolicy, ApprovalRequest, type AskOptions, AwaitingReason, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CORE_PLANNER_PROMPT, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompaction, ConversationEditError, type ConversationFork, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationTurn, type ConversationVariant, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, DiscoveredModel, type EnvAdmission, EnvConfig, type ExecFileFn, type ExecImpl, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GREP_PCRE_PROBE_ARGS, GeminiService, type GitExecFn, GlobOptions, type GrepInvocation, GrepOptions, type GrepRegex, type HasBinFn, HomeTranscriptReader, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, IWorktreeIsolation, IsolationHandoff, IsolationLandedTask, IsolationMergeResult, IsolationOutcome, IsolationRun, IsolationTaskRecord, IsolationTaskStatus, IsolationView, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, LegacyPlanState, type LiveOutputLookup, type LiveTail, type LiveTailOptions, type MappedTool, MergeGateView, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PlannerSubmission, PlannerToolHandler, PlannerUsage, type PluginSource, type PrdBlock, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, QueuedMessage, QueuedTaskMessage, REFUSED_COMMANDS, ReadFileOpts, RepairEvidence, type RepairLoopOpts, type RepairVerdict, RepoGroupLayout, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, ResolveContext, type RewindTarget, RunnerApprovals, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, RunnerSpawnOptions, RunnerTransport, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SaveSession, Session, SessionBroadcaster, type SessionData, type SessionDeps, SessionMessage, type SessionMeta, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredSessionCapability, StructuredTurnEnd, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, type TaskAttemptSnapshot, TaskCompleteArgs, TaskControlError, TaskIsolation, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, type TaskOrchestratorDeps, type TaskOrchestratorOptions, type TaskOutputAttempt, type TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskSnapshot, TaskStartOptions, TaskTokenScope, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type TranscriptQuery, type TranscriptReader, type TransportRoute, TransportRouter, TreeSnapshot, UsageRecord, type UserSettings, Verdict, VerdictEngine, type VerdictListener, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConflictRepairPrompt, buildConflictResolutionPrompt, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildSplitPrompt, buildSubagentSystemPrompt, canContinue, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, composeContinuationPrompt, configuredProviders, continuability, createAiService, createSession, createSkillsService, createTaskAdapter, createTaskOrchestrator, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, defuseMarkers, deleteSession, describeMergeResult, discoverGeminiModels, effectiveAllowlist, ensureDir, ensurePrivateDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, hasTmux, idSegment, includeGlobFor, isCliProvider, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, listTaskLogAttempts, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseTaskQueryJson, pendingEditRulesBlock, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, readTaskLog, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, retargetTaskRunner, routeTransport, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionDataDir, sessionRuntimeSettings, stateExists, stripModelPrefix, summarizeOutput, supportsTaskMode, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, withPath, writePrivateFile };
+export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AdoptSessionResponse, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApplyTaskOpsResult, ApprovalAnswer, type ApprovalAnswerResponse, ApprovalDecision, ApprovalMode, ApprovalPolicy, ApprovalRequest, type ApprovalsResponse, type AskOptions, AwaitingReason, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CORE_PLANNER_PROMPT, type CancelPlanningResponse, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, type CommandDescriptor, type CommandResponse, type CommandTier, type CommandsResponse, type ComposeOptions, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompactResponse, type ConversationCompaction, ConversationEditError, type ConversationFork, type ConversationForkResponse, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationRewindResponse, type ConversationTurn, type ConversationVariant, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, type DaemonErrorCode, DiscoveredModel, type EnvAdmission, EnvConfig, type ErrorBody, type ExecFileFn, type ExecImpl, type ExecuteResponse, FindSymbolOptions, type ForceSendResponse, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GREP_PCRE_PROBE_ARGS, GeminiService, type GeneratePlanResponse, type GitExecFn, GlobOptions, type GrepInvocation, GrepOptions, type GrepRegex, HARNESS_PLANNER_REASON, type HasBinFn, HomeTranscriptReader, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, IWorktreeIsolation, type IsolationDiffResponse, IsolationHandoff, IsolationLandedTask, type IsolationMergeResponse, IsolationMergeResult, IsolationOutcome, IsolationRun, IsolationTaskRecord, IsolationTaskStatus, IsolationView, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, LegacyPlanState, type LiveOutputLookup, type LiveTail, type LiveTailOptions, type MappedTool, type MergeGateEntry, type MergeGateResponse, MergeGateView, ModelResolver, type ModelResolverDeps, type ModelsResponse, type ModifyPlanRequest, NoPlanError, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, type OkResponse, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, PlanParseError, type PlanRequest, type PlanResponse, PlanState, PlanStatus, PlanStore, Planner, type PlannerBackendEntry, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PlannerSubmission, PlannerToolHandler, PlannerTurnDiscardedError, PlannerTurnStoppedError, type PlannerUsability, PlannerUsage, type PluginSource, type PrdBlock, type PrdResponse, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, QueuedMessage, QueuedTaskMessage, REFUSED_COMMANDS, ReadFileOpts, type RemoveMessageResponse, RepairEvidence, type RepairLoopOpts, type RepairVerdict, RepoGroupLayout, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, type ResolveConflictResponse, ResolveContext, type RewindTarget, type RewindTargetsResponse, RunnerApprovals, type RunnerCatalog, type RunnerEntry, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, RunnerSpawnOptions, RunnerTransport, type RunnersResponse, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SaveSession, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionListResponse, SessionMessage, type SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionResponse, type SessionRuntimeSettings, type SettingsResponse, SettingsService, type SettingsUpdateResponse, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, type StopResponse, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredSessionCapability, StructuredTurnEnd, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, type TaskAttemptSnapshot, TaskCompleteArgs, TaskControlError, TaskIsolation, type TaskLogAttemptsResponse, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, type TaskLogResponse, type TaskMessageResponse, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, type TaskOrchestratorDeps, type TaskOrchestratorOptions, type TaskOutputAttempt, type TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskSnapshot, TaskStartOptions, TaskTokenScope, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type TranscriptQuery, type TranscriptReader, type TransportRoute, TransportRouter, TreeSnapshot, UsageRecord, type UserSettings, Verdict, VerdictEngine, type VerdictListener, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorkspacesResponse, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConflictRepairPrompt, buildConflictResolutionPrompt, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildSplitPrompt, buildSubagentSystemPrompt, canContinue, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, composeContinuationPrompt, configuredProviders, continuability, createAiService, createSession, createSkillsService, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, defuseMarkers, deleteSession, describeMergeResult, discoverGeminiModels, effectiveAllowlist, ensureDir, ensurePrivateDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, hasTmux, idSegment, includeGlobFor, isCliProvider, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, listTaskLogAttempts, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseTaskQueryJson, pendingEditRulesBlock, plannerBackendEntries, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, readTaskLog, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, retargetTaskRunner, routeTransport, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionDataDir, sessionRuntimeSettings, stateExists, stripModelPrefix, summarizeOutput, supportsTaskMode, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, withPath, writePrivateFile };