@ordewell/core 0.10.1 → 0.10.3

package/dist/index.d.mts

@@ -1,13 +1,13 @@
-import { ac as Task, E as ExecutionActor, q as IsolationMergeResult, e as ExecutionRecord, f as GuardTrip, ab as SupervisorLevel, d as ExecutionCommandName, G as GuardTarget, $ as RunnerId, c as DiscoveredModel, W as ResearchProgress, V as ResearchLogEntry, C as ConversationMessage, a4 as SkillInfo, a5 as SkillLoad, a9 as SkillsService, L as LegacyPlanState, K as PlanStatus, m as IsolationLandedTask, I as IWorktreeIsolation, z as IsolationTaskStatus, H as PlanIsolation, ao as UsageRecord, Z as ResearchToolType, O as PlannerUsage, ak as TaskSnapshot, J as PlanState, F as IsolationView, aq as Verdict, aj as TaskSkillSnapshot } from './Task-CxwnCJLi.mjs';
-export { A as AttemptUsage, a as AwaitingReason, B as BUILTIN_SKILL_NAMES, D as DEFAULT_RUNNERS, b as DEFAULT_SUPERVISOR_RETRY_LIMIT, g as IntegrationDisposal, h as InvalidSkill, i as IsolationAvailability, j as IsolationHandoff, k as IsolationHandoffRepo, l as IsolationInactiveReason, n as IsolationLanding, o as IsolationMergeBlock, p as IsolationMergeBlockReason, r as IsolationOutcome, s as IsolationPruneResult, t as IsolationRemoval, u as IsolationRepo, v as IsolationRun, w as IsolationTaskRecord, x as IsolationTaskRef, y as IsolationTaskRepo, M as ModelUsage, N as PlanUsage, Q as PreparedTask, R as PreservedWork, S as RefusedRemoval, T as RepairEvidence, U as RepoGroupLayout, X as ResearchStep, Y as ResearchStepOutcome, _ as RunSettings, a0 as SetupFailure, a1 as ShadowedSkill, a2 as SkillAppliesTo, a3 as SkillCatalog, a6 as SkillLoadNotice, a7 as SkillMetadata, a8 as SkillSource, af as TaskIsolation, ag as TaskIsolationState, ah as TaskModelAssignment, al as TaskStatus, am as TreeSnapshot, an as UsageLine, ap as UsageTotals, ar as VerificationCheck, as as addAttemptUsage, at as addModelUsage, au as addPlannerUsage, av as addUsage, aw as addUsageTotals, ax as createEmptyPlan, ay as createSkillsService, az as createTask, aA as endAttemptUsage, aB as flattenTasks, aC as flattenTasksWithParents, aD as isAwaitingReason, aE as isMeasured, aF as isSupervisorLevel, aG as isUserMessage, aH as migratePlanState, aI as partedPromptUsage, aJ as pausedOnLimit, aK as planUsage, aL as plannerContextFill, aM as rejoinPlanTree, aN as startAttemptUsage, aO as usageLine } from './Task-CxwnCJLi.mjs';
-import { v as LiveTailOptions, L as LiveTail, R as PlannerModes, ao as TaskOp, t as IsolatedExecution, a6 as SessionBroadcaster, b as ApplyTaskOpsResult, ab as SkillLookup, a8 as SessionNotice, q as EditCatalog, a7 as SessionMessage, Q as PlanStore, ap as TaskOrchestrator, u as IsolationRunController, O as OrchestratorObserver, am as TaskLogEvent, I as INotification, s as GlobalRunSettings, _ as RunView, W as RunMergeView, as as TaskOutputSource, aJ as UserSettings, ag as SurfacePlan, ah as SurfacePlanState } from './plan-utils-CKXdD1AD.mjs';
-export { A as ACT_RISK, a as AUTORUN_RISK, c as ApprovalBlock, d as ApprovalStatus, e as AutoMergeTrigger, B as BlockingSubject, C as CHECKPOINT_TRUNCATE_LENGTH, f as CommandBlock, g as CommandStatus, h as CompactionBlock, i as ConversationInput, j as ConversationView, D as DiffRow, k as DiffRowKind, l as DiffStat, m as DisplayBlock, E as EMPTY_CONVERSATION, n as EMPTY_HOLD, o as EMPTY_RUN, p as EMPTY_TASK_LOG, r as ExecutionSummary, G as GatedConversation, w as LocalEntry, M as MessageBlock, x as MessageRole, N as NOT_STARTED, y as NO_TURN, z as NewTaskFields, F as NotificationAction, H as OutputPreview, P as PlanBlock, J as PlanMarkerStatus, K as PlanSnapshot, S as PromptHold, T as RUN_SETTINGS_DEFAULTS, V as RunInput, X as RunSettingsError, Y as RunTask, Z as RunTaskStatus, $ as RunnerLoadedBlock, a0 as SUPERVISOR_LEVEL_LABEL, a1 as SerializedConversationMessage, a2 as SerializedPendingTurn, a3 as SerializedPlan, a4 as SerializedTask, a5 as SerializedTaskStatus, a9 as SettingsService, aa as SkillLoadBlock, ac as SkillToken, ad as SubagentBlock, ae as SubagentChild, af as SubagentStatus, ai as SurfaceTask, aj as TakenPrompt, ak as TaskAttemptSnapshot, al as TaskControlError, an as TaskLogView, aq as TaskOrchestratorDeps, ar as TaskOrchestratorOptions, at as TaskRef, au as TaskRowAction, av as TaskRowContext, aw as TaskRowIsolation, ax as TaskRowKind, ay as TaskRowPlacement, az as TaskRowSubject, aA as TaskRowUsage, aB as TaskRowView, aC as TaskStatusKind, aD as ThinkingDisplayBlock, aE as ToolBlock, aF as ToolHeadline, aG as ToolStatus, aH as TurnGate, aI as UsageBlock, aK as aheadOfDraft, aL as applyTaskOps, aM as approvalLabel, aN as automergeSummary, aO as autorunSummary, aP as awaitingLabel, aQ as blockedByLabel, aR as blockingFailures, aS as canMergeTasks, aT as canSetDependencies, aU as canSplitTask, aV as capConflictFiles, aW as classifyOutcome, aX as coalesceTaskLog, aY as dependencyCandidates, aZ as dependentsNotice, a_ as dependentsOf, a$ as diffRows, b0 as diffStat, b1 as diffSummary, b2 as digestTaskLog, b3 as drainNext, b4 as executionSummary, b5 as followTurn, b6 as fromTranscript, b7 as getSettingsPath, b8 as hasHiddenDetail, b9 as holdPrompt, ba as isTaskRunning, bb as loadedSkillTokens, bc as markAction, bd as markRequestFor, be as namedRepos, bf as newTaskFields, bg as opsEditable, bh as outputLines, bi as outputPreview, bj as parseCount, bk as parseSwitch, bl as parseTaskOpsJson, bm as pastGateConfirmation, bn as reduceConversation, bo as reduceRun, bp as reduceTaskLog, bq as replayTaskLog, br as resolveTaskRef, bs as resumeLabel, bt as resumeTime, bu as runSettingsOf, bv as runnerToolSubject, bw as serializePlan, bx as serializeTask, by as serializeTaskStatus, bz as skillTokens, bA as skippedLabel, bB as stopTurn, bC as summarizeToolCall, bD as supervisorSummary, bE as surfacePlan, bF as surfacePlanState, bG as takeAt, bH as taskLogForSurface, bI as taskOrderLabel, bJ as taskRef, bK as taskRefOf, bL as taskRowActions, bM as taskRowView, bN as taskStartedNotice, bO as taskStatusKind, bP as textHasTaskOps, bQ as titledRefs, bR as titledTaskRef, bS as titledTaskRefOf, bT as toTaskLogEvent, bU as toolHeadline, bV as trimToolOutput, bW as truncateCheckpointSummary, bX as unsendAll, bY as unsendLatest } from './plan-utils-CKXdD1AD.mjs';
-import { I as IApproval, y as IConfig, d as AgentProcessDeps, a as AgentAdapter, _ as OrdewellMcpServer, a5 as PlannerToolHandler, ac as ResearchShell, p as ApprovalRequest, j as ApprovalDecision, i as ApprovalAnswer, z as IRunner, f as AiProvider, a8 as ProviderModelLists, m as ApprovalModeSetting, ap as RunnerRegistry, Z as OrchestratorOption, aC as TaskModeAgentAdapter, e as AgentStartOptions, c as AgentEvent, ah as RunnerCommand, a6 as ProjectMcpServer, n as ApprovalPolicy, B as IRunnerSession, az as TaskCompleteArgs, r as CheckpointAnswer, au as StructuredTurnEnd, at as StructuredEvent, aB as TaskMessageFrom, aa as QueuedTaskMessage, aH as TaskStartOptions, aI as TaskTokenScope, al as RunnerManifest, aG as TaskRunnerFlags } from './IRunner-hWAJC4hg.mjs';
-export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, k as ApprovalKind, l as ApprovalMode, o as ApprovalPolicyOptions, q as ApprovalSource, C as CatalogModel, s as CheckpointArgs, t as CommandClassification, u as CommandTier, v as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, w as DENY_ALL, x as DiscoveryCommand, E as EditPlanArgs, F as FetchAllProviderModelsOptions, G as GIT_READONLY_SUBCOMMANDS, H as InvokedCommand, L as LineBuffer, J as ListModelsArgs, K as ListRunnersArgs, M as LoadSkillArgs, N as McpClientConfig, O as McpCredential, P as McpTool, Q as McpToolContext, R as McpToolReply, S as MessageTaskArgs, T as ModelCatalog, U as ModelShortcut, V as ORCHESTRATOR_SHORTCUTS, W as ORDEWELL_MCP_PATH, X as ORDEWELL_MCP_SERVER_NAME, Y as OneTaskArgs, $ as OwnerOnlyFile, a0 as PLANNER_EXECUTION_TOOLS, a1 as PLANNER_TOOLS, a2 as PlannerAllowlist, a3 as PlannerStartOptions, a4 as PlannerTokenScope, a7 as ProviderCredentialSource, a9 as ProviderModelsResult, ab as REFUSED_COMMANDS, ad as ResearchShellDeps, ae as RetryTaskArgs, af as RunCommandArgs, ag as RunPlanArgs, ai as RunnerCommandKind, aj as RunnerEntry, ak as RunnerFeatures, am as RunnerMcpServer, an as RunnerMode, ao as RunnerModelDiscovery, aq as ShellDialect, ar as SpawnFn, as as StandingDecision, av as SubmitPlanArgs, aw as TASK_COMPLETE_TOOL, ax as TASK_COMPLETION_CONTRACT, ay as TASK_TOOLS, aA as TaskDiffArgs, aD as TaskModeUnsupportedError, aE as TaskOutputArgs, aF as TaskQueryArgs, aJ as TaskToolHandler, aK as approvalScopes, aL as classifyCommand, aM as clearResearchShellCache, aN as collectProviderCredentials, aO as commandAllowedBy, aP as effectiveApprovalMode, aQ as enabledRunners, aR as fetchAllProviderModels, aS as findRunnerCommand, aT as isGranted, aU as isRunnerApproval, aV as knownModelId, aW as mcpClientConfig, aX as ownerOnlyConfigFile, aY as parseAllowlist, aZ as parseApprovalModeSetting, a_ as researchShellWarning, a$ as researchToolsPath, b0 as resolveModelShortcut, b1 as resolveProvider, b2 as resolveResearchShell, b3 as scopeAllowed, b4 as sharedMcpServer, b5 as toApprovalDecision, b6 as toOrchestratorOptions, b7 as toolAllowed } from './IRunner-hWAJC4hg.mjs';
-import { T as ToolOutcome, I as IFileSystem, R as ReadFileOpts, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-Bj6fy1cG.mjs';
-export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-Bj6fy1cG.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-m1d8Cb-j.mjs';
-export { a as autonomyLevelLabel, p as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-m1d8Cb-j.mjs';
+import { af as Task, E as ExecutionActor, r as IsolationMergeResult, f as ExecutionRecord, g as GuardTrip, ae as SupervisorLevel, e as ExecutionCommandName, G as GuardTarget, a2 as RunnerId, d as DiscoveredModel, Z as ResearchProgress, Y as ResearchLogEntry, C as ConversationMessage, a7 as SkillInfo, a8 as SkillLoad, ac as SkillsService, L as LegacyPlanState, N as PlanStatus, n as IsolationLandedTask, I as IWorktreeIsolation, F as IsolationTaskStatus, J as PlanIsolation, ar as UsageRecord, a0 as ResearchToolType, Q as PlannerUsage, an as TaskSnapshot, K as PlanState, H as IsolationView, at as Verdict, am as TaskSkillSnapshot } from './Task-CRVIqSfy.mjs';
+export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, D as DEFAULT_RUNNERS, c as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as IntegrationDisposal, i as InvalidSkill, j as IsolationAvailability, k as IsolationHandoff, l as IsolationHandoffRepo, m as IsolationInactiveReason, o as IsolationLanding, p as IsolationMergeBlock, q as IsolationMergeBlockReason, s as IsolationOutcome, t as IsolationPruneResult, u as IsolationRemoval, v as IsolationRepo, w as IsolationRun, x as IsolationTaskRecord, y as IsolationTaskRef, z as IsolationTaskRepo, M as ModelUsage, O as PlanUsage, R as PrepareIntent, S as PreparedTask, T as PreservedWork, U as PreviousWork, V as RefusedRemoval, W as RepairEvidence, X as RepoGroupLayout, _ as ResearchStep, $ as ResearchStepOutcome, a1 as RunSettings, a3 as SetupFailure, a4 as ShadowedSkill, a5 as SkillAppliesTo, a6 as SkillCatalog, a9 as SkillLoadNotice, aa as SkillMetadata, ab as SkillSource, ai as TaskIsolation, aj as TaskIsolationState, ak as TaskModelAssignment, ao as TaskStatus, ap as TreeSnapshot, aq as UsageLine, as as UsageTotals, au as VerificationCheck, av as addAttemptUsage, aw as addModelUsage, ax as addPlannerUsage, ay as addUsage, az as addUsageTotals, aA as createEmptyPlan, aB as createSkillsService, aC as createTask, aD as endAttemptUsage, aE as flattenTasks, aF as flattenTasksWithParents, aG as isAwaitingReason, aH as isMeasured, aI as isSupervisorLevel, aJ as isUserMessage, aK as migratePlanState, aL as partedPromptUsage, aM as pausedOnLimit, aN as planUsage, aO as plannerContextFill, aP as rejoinPlanTree, aQ as startAttemptUsage, aR as usageLine, aS as waitsForApproval } from './Task-CRVIqSfy.mjs';
+import { ah as StartAdmission, w as LiveTailOptions, L as LiveTail, U as PlannerModes, at as TaskOp, u as IsolatedExecution, aa as SessionBroadcaster, b as ApplyTaskOpsResult, af as SkillLookup, ac as SessionNotice, q as EditCatalog, ab as SessionMessage, T as PlanStore, au as TaskOrchestrator, v as IsolationRunController, O as OrchestratorObserver, ar as TaskLogEvent, I as INotification, s as GlobalRunSettings, a1 as RunView, Z as RunMergeView, ax as TaskOutputSource, aO as UserSettings, al as SurfacePlan, am as SurfacePlanState } from './plan-utils-KU1Rse82.mjs';
+export { A as ACT_RISK, a as AUTORUN_RISK, c as ApprovalBlock, d as ApprovalStatus, e as AutoMergeTrigger, B as BlockingSubject, C as CHECKPOINT_TRUNCATE_LENGTH, f as CommandBlock, g as CommandStatus, h as CompactionBlock, i as ConversationInput, j as ConversationView, D as DiffRow, k as DiffRowKind, l as DiffStat, m as DisplayBlock, E as EMPTY_CONVERSATION, n as EMPTY_HOLD, o as EMPTY_RUN, p as EMPTY_TASK_LOG, r as ExecutionSummary, G as GatedConversation, H as HeldEdit, t as HeldEditMark, x as LocalEntry, M as MarkdownToken, y as MessageBlock, z as MessageRole, N as NOT_STARTED, F as NO_TURN, J as NewTaskFields, K as NotificationAction, P as OutputPreview, Q as PlanBlock, R as PlanMarkerStatus, S as PlanSnapshot, V as PromptHold, W as RUN_SETTINGS_DEFAULTS, Y as RunInput, _ as RunSettingsError, $ as RunTask, a0 as RunTaskStatus, a2 as RunnerLoadedBlock, a3 as STOPPED_BEFORE_START, a4 as SUPERVISOR_LEVEL_LABEL, a5 as SerializedConversationMessage, a6 as SerializedPendingTurn, a7 as SerializedPlan, a8 as SerializedTask, a9 as SerializedTaskStatus, ad as SettingsService, ae as SkillLoadBlock, ag as SkillToken, ai as SubagentBlock, aj as SubagentChild, ak as SubagentStatus, an as SurfaceTask, ao as TakenPrompt, ap as TaskAttemptSnapshot, aq as TaskControlError, as as TaskLogView, av as TaskOrchestratorDeps, aw as TaskOrchestratorOptions, ay as TaskRef, az as TaskRowAction, aA as TaskRowContext, aB as TaskRowIsolation, aC as TaskRowKind, aD as TaskRowPlacement, aE as TaskRowSubject, aF as TaskRowUsage, aG as TaskRowView, aH as TaskStatusKind, aI as ThinkingDisplayBlock, aJ as ToolBlock, aK as ToolHeadline, aL as ToolStatus, aM as TurnGate, aN as UsageBlock, aP as WAITS_FOR_APPROVAL_LABEL, aQ as aheadOfDraft, aR as applyTaskOps, aS as approvalLabel, aT as automergeSummary, aU as autorunSummary, aV as awaitingLabel, aW as blockedByLabel, aX as blockingFailures, aY as canMergeTasks, aZ as canSetDependencies, a_ as canSplitTask, a$ as capConflictFiles, b0 as classifyOutcome, b1 as coalesceTaskLog, b2 as dependencyCandidates, b3 as dependentsNotice, b4 as dependentsOf, b5 as diffRows, b6 as diffStat, b7 as diffSummary, b8 as digestTaskLog, b9 as drainNext, ba as executionSummary, bb as followTurn, bc as fromTranscript, bd as getSettingsPath, be as hasHiddenDetail, bf as holdPrompt, bg as isTaskRunning, bh as loadedSkillTokens, bi as markAction, bj as markRequestFor, bk as markdownHtml, bl as markdownTokens, bm as namedRepos, bn as newTaskFields, bo as opsEditable, bp as outputLines, bq as outputPreview, br as parseCount, bs as parseSwitch, bt as parseTaskOpsJson, bu as pastGateConfirmation, bv as reconcileApprovals, bw as reduceConversation, bx as reduceRun, by as reduceTaskLog, bz as replayTaskLog, bA as resolveTaskRef, bB as resumeLabel, bC as resumeTime, bD as runSettingsOf, bE as runnerToolSubject, bF as serializePlan, bG as serializeTask, bH as serializeTaskStatus, bI as skillTokens, bJ as skippedLabel, bK as stopTurn, bL as summarizeToolCall, bM as supervisorSummary, bN as surfacePlan, bO as surfacePlanState, bP as takeAt, bQ as taskLogForSurface, bR as taskOrderLabel, bS as taskRef, bT as taskRefOf, bU as taskRowActions, bV as taskRowView, bW as taskStartedNotice, bX as taskStatusKind, bY as textHasTaskOps, bZ as titledRefs, b_ as titledTaskRef, b$ as titledTaskRefOf, c0 as toTaskLogEvent, c1 as toolHeadline, c2 as trimToolOutput, c3 as truncateCheckpointSummary, c4 as unsendAll, c5 as unsendLatest } from './plan-utils-KU1Rse82.mjs';
+import { I as IApproval, y as IConfig, d as AgentProcessDeps, a as AgentAdapter, _ as OrdewellMcpServer, a6 as PlannerToolHandler, ad as ResearchShell, p as ApprovalRequest, j as ApprovalDecision, i as ApprovalAnswer, z as IRunner, a3 as PlannerBackendId, a9 as ProviderModelLists, f as AiProvider, m as ApprovalModeSetting, aq as RunnerRegistry, Z as OrchestratorOption, aD as TaskModeAgentAdapter, e as AgentStartOptions, c as AgentEvent, ai as RunnerCommand, a7 as ProjectMcpServer, n as ApprovalPolicy, B as IRunnerSession, aA as TaskCompleteArgs, r as CheckpointAnswer, av as StructuredTurnEnd, au as StructuredEvent, aC as TaskMessageFrom, ab as QueuedTaskMessage, aI as TaskStartOptions, aJ as TaskTokenScope, am as RunnerManifest, aH as TaskRunnerFlags } from './IRunner-CXdYyIZo.mjs';
+export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, k as ApprovalKind, l as ApprovalMode, o as ApprovalPolicyOptions, q as ApprovalSource, C as CatalogModel, s as CheckpointArgs, t as CommandClassification, u as CommandTier, v as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, w as DENY_ALL, x as DiscoveryCommand, E as EditPlanArgs, F as FetchAllProviderModelsOptions, G as GIT_READONLY_SUBCOMMANDS, H as InvokedCommand, L as LineBuffer, J as ListModelsArgs, K as ListRunnersArgs, M as LoadSkillArgs, N as McpClientConfig, O as McpCredential, P as McpTool, Q as McpToolContext, R as McpToolReply, S as MessageTaskArgs, T as ModelCatalog, U as ModelShortcut, V as ORCHESTRATOR_SHORTCUTS, W as ORDEWELL_MCP_PATH, X as ORDEWELL_MCP_SERVER_NAME, Y as OneTaskArgs, $ as OwnerOnlyFile, a0 as PLANNER_EXECUTION_TOOLS, a1 as PLANNER_TOOLS, a2 as PlannerAllowlist, a4 as PlannerStartOptions, a5 as PlannerTokenScope, a8 as ProviderCredentialSource, aa as ProviderModelsResult, ac as REFUSED_COMMANDS, ae as ResearchShellDeps, af as RetryTaskArgs, ag as RunCommandArgs, ah as RunPlanArgs, aj as RunnerCommandKind, ak as RunnerEntry, al as RunnerFeatures, an as RunnerMcpServer, ao as RunnerMode, ap as RunnerModelDiscovery, ar as ShellDialect, as as SpawnFn, at as StandingDecision, aw as SubmitPlanArgs, ax as TASK_COMPLETE_TOOL, ay as TASK_COMPLETION_CONTRACT, az as TASK_TOOLS, aB as TaskDiffArgs, aE as TaskModeUnsupportedError, aF as TaskOutputArgs, aG as TaskQueryArgs, aK as TaskToolHandler, aL as approvalScopes, aM as classifyCommand, aN as clearResearchShellCache, aO as collectProviderCredentials, aP as commandAllowedBy, aQ as effectiveApprovalMode, aR as enabledRunners, aS as fetchAllProviderModels, aT as findRunnerCommand, aU as isGranted, aV as isRunnerApproval, aW as knownModelId, aX as mcpClientConfig, aY as ownerOnlyConfigFile, aZ as parseAllowlist, a_ as parseApprovalModeSetting, a$ as researchShellWarning, b0 as researchToolsPath, b1 as resolveModelShortcut, b2 as resolveProvider, b3 as resolveResearchShell, b4 as scopeAllowed, b5 as sharedMcpServer, b6 as toApprovalDecision, b7 as toOrchestratorOptions, b8 as toolAllowed } from './IRunner-CXdYyIZo.mjs';
+import { T as ToolOutcome, I as IFileSystem, R as ReadFileOpts, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-B8Nkgg4e.mjs';
+export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-B8Nkgg4e.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-geqjKkLY.mjs';
+export { a as autonomyLevelLabel, p as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-geqjKkLY.mjs';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
 import 'zod/v4';
@@ -59,7 +59,7 @@ type ExecutionCommand = {
  | {
     command: 'merge_all';
 }
-/** End a task as skipped: nothing it did lands, and its dependents go ahead without it. `reason` is required of anyone but the user. */
+/** End a task as skipped: nothing it did lands, and its dependents go ahead without it once the work it waited on is done. `reason` is required of anyone but the user. */
  | {
     command: 'skip_task';
     task: string;
@@ -125,7 +125,7 @@ interface ExecutionHost {
     planApproved(): boolean;
     /** The user approved this task: it was in the plan they executed, or they started it themselves. */
     taskApproved(taskId: string): boolean;
-    /** A command of the user's own approves what it starts. */
+    /** A start the user consented to approves these tasks, before it acts. */
     approve(taskIds: readonly string[]): void;
     /** Full autonomy: starts follow plan approval without a question. */
     autonomous(): boolean;
@@ -137,14 +137,18 @@ interface ExecutionHost {
     startsHeld(): boolean;
     /** Work is running right now. */
     hasLiveWork(): boolean;
+    /** Something will start without being asked again: a start admitted and not yet claimed, or a scheduled resume. */
+    startsPending(): boolean;
+    /** Admit a start that waits before it claims; see {@link StartAdmission}. */
+    admitStart(): StartAdmission;
     /** The task's attempt is live: starting, running or landing. */
     running(taskId: string): boolean;
     maxParallel(): number;
     /** The run waits on the user to stash or skip isolation before anything starts. */
     runBlocked(): boolean;
-    /** A dependency is met once its work is where the dependent will run. */
-    dependencyMet(depId: string): boolean;
-    /** The dependencies a task waits on at its merge gate (ADR-0020). */
+    /** The tasks a task's dependencies still hold it back for: unmet dependencies, or the unfinished work behind a skipped one. */
+    unmetDependencies(task: Readonly<Task>): string[];
+    /** The ancestors a task would wait on at its merge gate if it started now, whatever its status (ADR-0020). */
     mergeGate(taskId: string): string[];
     /** The failed tasks a task not started waits on through its dependencies (ADR-0034). */
     blockedBy(taskId: string): string[];
@@ -174,10 +178,16 @@ interface ExecutionHost {
      * named — that lands only when its reply ends.
      */
     heldEdit(taskId?: string): boolean;
-    /** The task as the open turn's held edit leaves it; undefined when that edit removes it. */
-    asEdited(taskId: string): Task | undefined;
-    /** Run the command again, as the same actor, once the open turn's reply has landed its edit; `intent` names it if it never does. */
-    deferUntilLanded(command: ExecutionCommand, actor: ExecutionActor, intent: string): void;
+    /** The plan's task tree as the open turn's held edit leaves it: as it is, when it holds none or one that would not apply. */
+    editedTasks(): readonly Task[];
+    /** The id of the task the open turn's held edit makes under this batch handle; undefined when it names none. */
+    heldHandle(name: string): string | undefined;
+    /**
+     * Run the command again, as the same actor, once the open turn's reply has
+     * landed its edit; `intent` names it if it never does. `admission` is
+     * released once it has run or been dropped.
+     */
+    deferUntilLanded(command: ExecutionCommand, actor: ExecutionActor, intent: string, admission: StartAdmission): void;
     /** A command deferred behind an edit did not run once the edit landed: the user is told, and so is the planner's next turn. */
     queuedNotRun(text: string): void;
 }
@@ -204,34 +214,62 @@ declare class ExecutionCommands {
     private readonly guards;
     private readonly now;
     constructor(deps: ExecutionCommandsDeps);
-    run(asked: ExecutionCommand, actor: ExecutionActor): Promise<CommandOutcome>;
+    /**
+     * `admitted`: a deferred start's admission, taken as it was queued, which
+     * its owner releases; a start asked for now takes its own.
+     */
+    run(asked: ExecutionCommand, actor: ExecutionActor, admitted?: StartAdmission): Promise<CommandOutcome>;
+    /** A valid, consented call, from the user's answer where one is needed to the act and its record. */
+    private carryOut;
     /**
      * A command deferred behind the turn's edit, run now that the edit landed.
      * Nobody reads its answer, so one that does not run is kept as refused and
      * said, to the user and to the planner's next turn.
      */
-    replay(command: ExecutionCommand, actor: ExecutionActor): Promise<void>;
+    replay(command: ExecutionCommand, actor: ExecutionActor, admission: StartAdmission): Promise<void>;
     /**
-     * A start that waits for the turn's edit is judged now, against its task as
+     * A start that waits for the turn's edit is judged now, against the plan as
      * that edit leaves it — the edit counts as the change a retry needs — so one
-     * that could never run is refused while the caller still reads the answer.
+     * that could never run is refused while the caller still reads the answer,
+     * and one the user will be asked about says so. `located` is the task as the
+     * plan has it now, absent for a task the edit adds.
      */
     private judgeAsEdited;
     private tripped;
+    /** `approves` is null for a start that runs without asking, else what the user's yes would approve. */
     private defer;
+    /**
+     * The tasks a start approves, read from the plan as it stands at the
+     * command's last check. Autorun starts a plan as the user's standing
+     * instruction, so its start approves what it runs as the user's does; so
+     * does a start under its exception for added tasks. A yes on the card
+     * approves the tasks the card named, and no others.
+     */
+    private consented;
     /**
      * With autorun on and Full, a planner turn may start a task added after the
      * user approved the plan (ADR-0030). Read at each start, so switching either
      * off stops it at once; never on a plan the user has not approved.
      */
     private addedMayStart;
+    /**
+     * Guarded means "ask the user first": a planner start in the user's own
+     * turn asks, so tasks they have not approved go into the question rather
+     * than refusing it. The supervisor's starts stay within what the user
+     * approved (ADR-0029).
+     */
+    private asksToApprove;
     /**
      * Who may do what without the mandate (#23): the user's own call needs no
      * consent; a planner turn may always end or steer work, and starts it only
      * as the autonomy level says; the supervisor's level decides for it.
      */
     private consent;
-    /** Whether the command can run now, and how. Read afresh after a question, since answering takes time. */
+    /**
+     * Whether the command can run now, and how, judged against `tasks`: the
+     * plan, or the plan as the turn's held edit leaves it. Read afresh after a
+     * question, since answering takes time.
+     */
     private prepare;
     private prepareRunPlan;
     /** A start of one task: `run_task`, or a fresh `retry_task`, which also takes a task that failed or waits on the user. */
@@ -261,9 +299,16 @@ declare class ExecutionCommands {
      * waiting for input.
      */
     private prepareSkip;
-    /** Why a start is not the user's to have made, or null: the user's own call is its own approval. */
+    /**
+     * Why a start is not the user's to have made, or the task it asks them to
+     * approve, or null: the user's own call is its own approval.
+     */
     private unapproved;
-    /** The Guarded question, on the card the user answers other planner requests on. */
+    /**
+     * The Guarded question, on the card the user answers other planner requests
+     * on. It names every task a yes approves, since a yes is the user's
+     * approval of them as Execute plan would be.
+     */
     private question;
     /** What was asked, as "start task #4 "Title"". */
     private intent;
@@ -271,6 +316,8 @@ declare class ExecutionCommands {
     private keep;
     private all;
     private located;
+    /** A reference read against the plan as the held edit leaves it, where the handles its batch gives come first. */
+    private locateAsEdited;
     /** A reference as a caller writes one — see {@link resolveTaskRef}. */
     private locate;
 }
@@ -1077,6 +1124,14 @@ declare class PlannerConversation {
      * submission replaces an earlier one. False when no user turn is open.
      */
     submit(submission: PlannerSubmission): boolean;
+    /**
+     * Tell surfaces what the turn's edit would leave, from the same applier that
+     * lands it, so an edit that would not apply shows nothing. It stays shown
+     * from the moment it is handed in until it lands, is refused, or the turn
+     * ends: the backend's reply claims it, but it has not landed by then.
+     */
+    private showHeld;
+    private clearHeld;
     /**
      * The edit the open turn already holds, for a further edit in the same reply
      * to join rather than replace. Empty when it holds nothing; null when it holds
@@ -1284,6 +1339,8 @@ declare class PlannerConversation {
     private warnSkills;
     /** Validate + commit a task_ops turn atomically. Returns the errors on rejection (plan untouched). */
     private applyTaskOps;
+    /** The edit was refused as it landed: what it showed is not coming. */
+    private refusedHeld;
     /** Commit a settled (non-task_ops) turn through the host's mutation ritual. */
     private commit;
     /**
@@ -1847,8 +1904,48 @@ declare function formatSearchOutput(capped: CappedRows, root: string, opts: {
 }): string;
 
 declare function normalizeGeminiModel(id: string): string;
+/** A model and the effort it was chosen with; blank is the planner's own default. */
+interface PlannerChoice {
+    model: string;
+    effort: string;
+}
+/**
+ * Where a resolved model and effort came from. `configured` is a planner the
+ * user named, or a vendor, as configured; for an agent detection found,
+ * `inherited` is a configured model it can run. A planner whose configured
+ * model is not its own gets `remembered`, its last pick, or `none`, its own
+ * default; `request` is one request's model. Only `configured` and
+ * `remembered` are the user's own choice for that planner.
+ */
+type PlannerModelSource = 'configured' | 'inherited' | 'remembered' | 'request' | 'none';
+interface ResolvedChoice extends PlannerChoice {
+    source: PlannerModelSource;
+}
+/** Who plans, and the model and effort it is spawned with. */
+interface ResolvedPlanner extends ResolvedChoice {
+    provider: PlannerBackendId;
+}
+/**
+ * What a host is configured to plan with. The model and effort are inherited
+ * (the environment or `.env` at startup, an editor setting) unless the planner
+ * was named — `setting` (VS Code's `aiProvider`) or AI_PROVIDER — or the
+ * model was picked in this session.
+ */
+interface ConfiguredPlanner extends PlannerChoice {
+    setting?: string;
+    /**
+     * The planner a `/model` or `/planner` pick in this session made the model
+     * for. A pick belongs to that planner alone: once routing moves (its key
+     * removed), the model is configuration left for when it comes back, not a
+     * choice the planner now in effect made.
+     */
+    pickedFor?: PlannerBackendId;
+    /** One request's own model: it wins for that request and is never saved. */
+    override?: string;
+}
 declare abstract class BaseConfig implements IConfig {
-    abstract aiProvider: AiProvider;
+    private _routed;
+    abstract aiProvider: PlannerBackendId;
     abstract apiKey: string;
     abstract planningModel: string;
     abstract enabledRunners: string[];
@@ -1864,6 +1961,7 @@ declare abstract class BaseConfig implements IConfig {
     get researchSubagentModel(): string;
     get geminiModel(): string;
     get plannerThinkingEffort(): string | undefined;
+    private environmentPlannerChoice;
     get openaiBaseUrl(): string;
     get openaiApiKey(): string;
     get xaiBaseUrl(): string;
@@ -1928,8 +2026,69 @@ declare abstract class BaseConfig implements IConfig {
     get webReadBudget(): number;
     get approvalDefaults(): boolean;
     get approvalPreApproved(): string[];
-    protected static detectProvider(fallback: AiProvider): AiProvider;
+    /**
+     * Who plans when no surface setting names a planner: an explicit
+     * AI_PROVIDER, then a vendor whose key is in the environment,
+     * then an installed coding agent (ADR-0009), and openrouter only when there
+     * is none of those. One answer for every host, so they cannot drift apart.
+     */
+    protected detectProvider(): PlannerBackendId;
+    /**
+     * Who plans when no surface setting names a planner: an explicit
+     * AI_PROVIDER, then the vendor whose catalog lists the model, else
+     * `detectProvider`. The explicit choice comes first because a model id can
+     * sit in another vendor's catalog (`openai/gpt-4o` is on OpenRouter too),
+     * and the user named the planner, not the catalog. A vendor without a
+     * credential yields to an installed coding agent, because the TUI and
+     * `ordewell planner` persist ORCHESTRATOR_MODEL, and a model left over from
+     * a removed key would otherwise route a keyless first run to a planner that
+     * cannot plan. Without an agent the vendor still answers, so the preflight
+     * names it.
+     */
+    protected providerForModel(model: string | undefined, lists: ProviderModelLists | null | undefined): PlannerBackendId;
+    /**
+     * `providerForModel`, memoized against everything it reads rather than a
+     * flag each writer must remember to reset. A host keeps one config for a
+     * whole session or extension lifetime while keys, AI_PROVIDER, the model and
+     * the installed agent all change underneath it, from writers (a secret-store
+     * event, a settings route, the startup probe) that never see this instance;
+     * the memo must answer what a fresh config would. The lists are compared by
+     * identity because a host swaps the whole object on discovery.
+     */
+    protected routedProvider(model: string | undefined, lists: ProviderModelLists | null | undefined): PlannerBackendId;
+    /**
+     * Who plans, with which model and effort: the one rule every host's
+     * provider, model and effort getters read, so what a settings response
+     * shows is what is spawned. Resolved on each read and never saved: a key or
+     * a `/planner` pick added later must find the configured values as they were.
+     */
+    protected resolvePlanner(configured: ConfiguredPlanner, lists: ProviderModelLists | null | undefined): ResolvedPlanner;
+    /**
+     * `resolvePlanner`'s model and effort, for a getter that reads its model
+     * from other settings than the one `provider` was routed on
+     * (`planningModel`): judged against the planner in effect rather than
+     * routed again. A model picked in this session for this planner and a
+     * vendor's configured model are kept; a model picked for another planner
+     * is not this one's. A coding agent the user named keeps what is
+     * configured unless it is plainly a vendor's: naming the agent did not
+     * choose a slug left from an old setup. A request's own model wins.
+     */
+    protected plannerChoiceFor(provider: PlannerBackendId, configured: ConfiguredPlanner): ResolvedChoice;
+    /**
+     * The model ids a coding agent was last discovered serving, empty while
+     * discovery is cold. A host that holds a runner catalog supplies it: it is
+     * the only evidence that tells OpenCode's `provider/model` ids from an
+     * OpenRouter slug.
+     */
+    protected agentCatalog(_provider: PlannerBackendId): readonly string[];
 }
+/**
+ * Plainly a vendor's model, which coding agent `agent` cannot run: every
+ * vendor catalog id carries Ordewell's prefix (`openai:`) or is an OpenRouter
+ * `org/model` slug, a shape an agent that names its own models that way
+ * cannot rule out.
+ */
+declare function isVendorModelFor(agent: PlannerBackendId, model: string): boolean;
 
 /**
  * A fully `process.env`-backed IConfig for headless callers (e.g. the CLI's
@@ -1938,7 +2097,7 @@ declare abstract class BaseConfig implements IConfig {
  * subclass only supplies the abstract members from the environment.
  */
 declare class EnvConfig extends BaseConfig {
-    get aiProvider(): AiProvider;
+    get aiProvider(): PlannerBackendId;
     get apiKey(): string;
     get planningModel(): string;
     get enabledRunners(): string[];
@@ -2160,6 +2319,8 @@ declare class OpenAiService extends BaseAiService implements IAiService {
      * key the user had already replaced.
      */
     private getClient;
+    /** The vendor this service talks to; `createAiService` routes every other planner elsewhere. */
+    private vendor;
     ensureInit(): void;
     private requireModel;
     reset(): void;
@@ -2338,16 +2499,44 @@ declare class RunnerInstallation {
     clear(): void;
 }
 
-declare const PROVIDER_LABEL: Record<AiProvider, string>;
-declare const PROVIDER_SHORT_LABEL: Record<AiProvider, string>;
+/** The first of {@link findInstalledAgents}; null when none is usable. */
+declare function findInstalledPlanner(installation: Pick<RunnerInstallation, 'plannerUsability'>): Promise<PlannerBackendId | null>;
+/**
+ * Find the installed agent and record it, for a host to start at startup. A
+ * goal can be typed before the probe answers, so every planner turn waits on
+ * {@link installedPlannerDetected} rather than planning with openrouter.
+ */
+declare function detectInstalledPlanner(installation: Pick<RunnerInstallation, 'plannerUsability'>): Promise<PlannerBackendId | null>;
+/** Settles once the latest probe has recorded its answer; at once when none was started. */
+declare function installedPlannerDetected(): Promise<void>;
+/**
+ * Whether the latest probe has recorded its answer, for a check that must run
+ * at once when it can: a planner preflight read while the probe is out would
+ * judge the openrouter fallback the answer may replace.
+ */
+declare function installedPlannerAnswered(): boolean;
+declare function recordInstalledPlanner(id: PlannerBackendId | null): void;
+declare function recordedInstalledPlanner(): PlannerBackendId | null;
+/**
+ * The runners enabled while the user has never saved a choice: the agents the
+ * latest probe found installed, so a Codex-only or OpenCode-only host can plan
+ * and run on its first start; DEFAULT_RUNNERS while none was found or no probe
+ * has answered. Read on each call and never saved, so an agent installed later
+ * joins on the next probe and a saved choice — even an empty one — still wins.
+ * Every host's config reads it here, so the daemon, CLI, TUI and VS Code agree.
+ */
+declare function defaultEnabledRunners(): RunnerId[];
+/** For tests: the recorded default is process-wide, so one case's must not decide the next's. */
+declare function resetInstalledPlanner(): void;
+
 interface ProviderRegistration {
-    id: AiProvider;
+    id: PlannerBackendId;
     label: string;
     shortLabel: string;
     /** `cli` is a harness planner (ADR-0009): a local coding agent, not an HTTP vendor. */
     serviceType: 'openai' | 'google' | 'cli';
     /** Harness planners only: the runner id whose manifest, models and binary this provider drives. */
-    runnerId?: string;
+    runnerId?: RunnerId;
     defaultBaseUrl: string;
     apiKeyEnvVar: string;
     detectEnvVars: string[];
@@ -2358,10 +2547,25 @@ interface ProviderRegistration {
     discoversModels: boolean;
     modelPrefix?: string;
 }
-declare const ALL_PROVIDERS: Record<AiProvider, ProviderRegistration>;
+declare const PROVIDER_PRIORITY: AiProvider[];
+declare const PROVIDER_DETECT_PRIORITY: AiProvider[];
+
+/**
+ * Keyed by planner backend: every vendor has an entry, and a runner id has one
+ * only when that runner can plan, which the type cannot know.
+ */
+type ByPlannerBackend<T> = Readonly<Record<AiProvider, T>> & Readonly<Partial<Record<RunnerId, T>>>;
+declare const ALL_PROVIDERS: ByPlannerBackend<ProviderRegistration>;
+declare const PROVIDER_LABEL: ByPlannerBackend<string>;
+declare const PROVIDER_SHORT_LABEL: ByPlannerBackend<string>;
 declare function getProviderMeta(id: AiProvider): ProviderRegistration;
-declare function prefixModelId(provider: AiProvider, modelId: string): string;
-declare function stripModelPrefix(id: string, provider: AiProvider): string;
+declare function getProviderMeta(id: PlannerBackendId): ProviderRegistration | undefined;
+/** Whether a planner backend id names an API vendor, the kind that takes a key and a base URL. */
+declare function isApiProvider(id: PlannerBackendId): id is AiProvider;
+/** Whether an id names a planner backend at all: a vendor, or a runner that can plan. */
+declare function isPlannerBackend(id: string): id is PlannerBackendId;
+declare function prefixModelId(provider: PlannerBackendId, modelId: string): string;
+declare function stripModelPrefix(id: string, provider: PlannerBackendId): string;
 declare function resolveProviderFromPrefix(id: string): AiProvider | null;
 /**
  * The harness planners, in display order. Deliberately NOT part of
@@ -2371,10 +2575,8 @@ declare function resolveProviderFromPrefix(id: string): AiProvider | null;
  * that offer a planner picker concatenate the two lists and gate these on
  * `RunnerInstallation.plannerUsability`.
  */
-declare const CLI_PROVIDERS: AiProvider[];
-declare const PROVIDER_PRIORITY: AiProvider[];
-declare const PROVIDER_DETECT_PRIORITY: AiProvider[];
-declare function isOpenAiProvider(id: AiProvider): boolean;
+declare const CLI_PROVIDERS: readonly RunnerId[];
+declare function isOpenAiProvider(id: PlannerBackendId): boolean;
 /**
  * The one guard that separates a harness planner from an LLM vendor (ADR-0009).
  * Three places consult it: API-key resolution (skipped — the subscription is
@@ -2382,24 +2584,24 @@ declare function isOpenAiProvider(id: AiProvider): boolean;
  * the planner-model picker (fed by per-runner discovery, not the vendor
  * catalog).
  */
-declare function isCliProvider(id: AiProvider): boolean;
-/** The runner a harness planner drives, or null for a vendor provider. */
-declare function runnerForProvider(id: AiProvider): string | null;
+declare function isCliProvider(id: PlannerBackendId): boolean;
+/** The runner a harness planner drives, or null for a vendor provider or an unknown id. */
+declare function runnerForProvider(id: PlannerBackendId): RunnerId | null;
 /** The harness planner that wraps a given runner, or null when none does. */
-declare function providerForRunner(runner: string): AiProvider | null;
+declare function providerForRunner(runner: RunnerId): PlannerBackendId | 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
+ * One entry of the planner backend list (ADR-0009). `id` is the
+ * `PlannerBackendId` 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;
+    id: PlannerBackendId;
     label: string;
     kind: 'harness' | 'vendor';
     runner?: string;
@@ -3270,7 +3472,7 @@ interface RunnerCatalog {
 
 type ModelsByRunner = Partial<Record<RunnerId, DiscoveredModel[]>>;
 interface SessionCatalogDeps {
-    config: Pick<IConfig, 'enabledRunners' | 'autonomousMode'>;
+    config: Pick<IConfig, 'enabledRunners' | 'autonomousMode' | 'aiProvider'>;
     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). */
@@ -3400,6 +3602,8 @@ interface SessionEventRelayDeps {
     awaitingApproval?: (taskId: string) => number;
     /** What a task's waiting checkpoint asks, whole. */
     checkpointQuestion?: (taskId: string) => string | undefined;
+    /** The task waits for the user's approval to start (ADR-0035). */
+    waitsForApproval?: (taskId: string) => boolean;
 }
 /**
  * Every orchestrator event the relay announces. `onTaskSettled` is persistence
@@ -3426,6 +3630,7 @@ declare class SessionEventRelay {
     private readonly usage;
     private readonly awaitingApproval;
     private readonly checkpointQuestion;
+    private readonly waitsForApproval;
     /**
      * The in-flight turn's subagent activity, grouped one run per subagent so a
      * replay nests each step under its own brief/result. Folded into the plan's
@@ -3434,6 +3639,8 @@ declare class SessionEventRelay {
     private pendingSubagents;
     private statusHeld;
     private statusOwed;
+    /** The planner's requests announced and not yet settled, as they were announced: a surface joining now is owed them. */
+    private readonly announced;
     constructor(deps: SessionEventRelayDeps);
     /** `plan` is read per event: a Session with no plan (or mid-reset) announces nothing about tasks. */
     observer(plan: () => LegacyPlanState | null): RelayObserver;
@@ -3450,6 +3657,14 @@ declare class SessionEventRelay {
      */
     holdStatus<T>(op: () => T): T;
     releaseStatus(plan: LegacyPlanState | null): void;
+    approvalRequested(request: Extract<SessionMessage, {
+        type: 'approval_request';
+    }>): void;
+    approvalSettled(id: string, granted: boolean): void;
+    /** The planner's approval requests still waiting, in the order they were asked. */
+    announcedApprovals(): Extract<SessionMessage, {
+        type: 'approval_request';
+    }>[];
     executionComplete(plan: LegacyPlanState | null): void;
     /** `turnId`: the planner turn whose commit this is, when one is. */
     planGenerated(plan: LegacyPlanState | null, goal: string, turnId?: string): void;
@@ -3650,6 +3865,8 @@ declare class Session {
      * supervisor has first.
      */
     private sentHandoff;
+    /** The edit the open planner turn holds, as last announced: a surface that joins mid-turn is shown it. */
+    private sentHeld;
     private readonly notifications;
     private readonly onNotice?;
     private readonly modelResolver;
@@ -3667,6 +3884,15 @@ declare class Session {
     private readonly skillsService;
     private readonly conversation;
     private readonly turns;
+    /** Destroyed: a turn that waited for the planner to be found must not open on it. */
+    private closed;
+    /**
+     * Turns PlanTurns does not open, waiting at the planner gate, each ended
+     * with why it must not open: a Stop, a newer goal, or its plan scope ending.
+     */
+    private readonly openingsWaiting;
+    /** The conversation's opening, from admission until its turn settles; see {@link behindOpening}. */
+    private opening;
     private readonly editor;
     private readonly commands;
     private readonly supervision;
@@ -3711,7 +3937,11 @@ declare class Session {
      * one: nothing it would start is approved until the user executes it.
      */
     private heldEdit;
-    /** The task as the open turn's held edit leaves it: as it is, when it holds none or one that would not apply. */
+    /** The plan's tasks as the open turn's held edit leaves them: as they are, when it holds none or one that would not apply. */
+    private editedTasks;
+    /** {@link editedTasks}, with the id each of the held batch's handles names in them. */
+    private editedPlan;
+    /** The task as the open turn's held edit leaves it; undefined when that edit removes it. */
     private asEdited;
     /** The open planner turn is the supervisor's, acting at Act: its edits and added tasks are its own (ADR-0029). */
     private supervisorEditing;
@@ -3740,8 +3970,24 @@ declare class Session {
     private userRunSettings;
     /** A call at the seam, in the transcript where it happened and on every surface at once. */
     private recordExecution;
+    /**
+     * Whether the user approved this task to run (ADR-0029, ADR-0035): it was in
+     * the plan they executed, or they started it, added it or let it start since,
+     * and it has been in the plan ever since. The one reading of the approval
+     * record — the seam and the scheduler both ask it.
+     */
+    isApproved(taskId: string): boolean;
+    /** A task the scheduler leaves for the user to approve; see {@link waitsForApproval}. */
+    waitsForApproval(taskId: string): boolean;
     /** What the user approved to run (ADR-0029): a start of their own approves the task and its subtasks. */
     private approve;
+    /**
+     * A task that leaves the plan takes its approval with it, whichever route
+     * removed it: an edit, a merge or split, a whole plan that leaves it out.
+     * Approval is of the task the user saw, and a planner may later write a new
+     * task under the same id (ADR-0029).
+     */
+    private keepApprovals;
     private approveTask;
     /**
      * Answer an outstanding approval. Every surface funnels here — the web
@@ -3751,6 +3997,10 @@ declare class Session {
     resolveApproval(id: string, answer: ApprovalAnswer): boolean;
     /** Requests still waiting for an answer, replayed to a surface that connects mid-prompt. */
     outstandingApprovals(): PendingApproval[];
+    /** The planner's requests still waiting, as their cards were announced — what a surface (re)joining replays. */
+    announcedApprovals(): Extract<SessionMessage, {
+        type: 'approval_request';
+    }>[];
     /** Scopes the user granted this session — surfaced so a UI can show what is already allowed. */
     approvedScopes(): string[];
     /** The stable id this session persists under — matches the host's id when one was provided. */
@@ -3834,20 +4084,64 @@ declare class Session {
     /** See {@link TaskOrchestrator.hasLiveWork} — a spawned runner, not merely an armed scheduler. */
     get isExecuting(): boolean;
     get status(): 'approved' | 'running' | 'completed';
-    /** Whether a planner turn — a reply, a compaction, plan generation — holds the conversation. */
+    /**
+     * Throws {@link PlannerNotReadyError} when the planner this session's config
+     * selects cannot plan. Judged on the session's own config, so a model
+     * override sent with the request is the one judged; every planner turn
+     * passes it, and a host may call it first to refuse before it builds on
+     * the session.
+     */
+    assertPlannerReady(): void;
+    /**
+     * The planner gate for a turn {@link PlanTurns} does not open — an opening,
+     * plan generation, a compaction — the same one its turns pass: wait for the
+     * installed-planner probe, then judge the planner in use now. A wait is
+     * ended at once, not when the probe answers, by its caller's abort, a Stop,
+     * a newer goal or its plan scope ending ({@link endWaiting}): a turn that
+     * only learnt of these afterwards would open on a session that moved on.
+     *
+     * Null when the turn may open at once: awaited regardless, the turn would
+     * take the conversation a tick late, and a message sent alongside it would
+     * no longer be refused as one sent during it.
+     */
+    private plannerTurnMayOpen;
+    /** End every turn waiting at the planner gate before it opens; false when none was. */
+    private endWaiting;
+    /**
+     * Whether a planner turn — a reply, a compaction, plan generation — holds
+     * the conversation, or one admitted waits at the planner gate to: a host
+     * that read the wait as idle sent a follow-up as a new goal.
+     */
     get isPlannerBusy(): boolean;
     /**
      * 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.
+     * what it had — and ends as stopped. A turn still waiting at the planner
+     * gate is stopped too, before it opens, and so is every message sent behind
+     * either: the user stopped the planner, not one turn of it. False when
+     * there was neither.
      */
     abortPlannerTurn(): boolean;
-    generatePlan(goal: string, runners: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
+    /**
+     * The runners a first turn may plan for. None requested means every enabled
+     * one, read here, after the planner gate: until the installed-agent probe
+     * answers, the enabled default is a stale guess a request must not freeze.
+     */
+    private chosenRunners;
+    generatePlan(goal: string, runners?: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
     /**
      * Kick off the planner conversation (ADR-0002): research + the first planner
      * message. The conversation itself — transcript, live model context, turn
      * settlement — is {@link PlannerConversation}'s; the Session hosts it.
      */
-    startPlanning(goal: string, runners: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
+    startPlanning(goal: string, runners?: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
+    /**
+     * A message sent while the conversation's opening is pending answers it, so
+     * it goes after it rather than replacing the goal or being refused: held
+     * while the opening waits at the planner gate — there is no conversation
+     * yet to queue it on — and queued behind it once it holds the conversation.
+     * Null with no opening pending.
+     */
+    private behindOpening;
     /**
      * Every subsequent user reply in the planning conversation — clarifying
      * answers, outline confirm, a message during a run. One branch, no phase
@@ -4023,7 +4317,7 @@ declare class Session {
      * last did is not kept, so it is not here.
      */
     runSnapshot(): RunView;
-    /** The dependencies a task waits on at its merge gate (ADR-0020); empty when it waits for no Merge all. */
+    /** The ancestors a task waits on at its merge gate (ADR-0020); empty when it waits for no Merge all. */
     mergeGate(taskId: string): string[];
     /** What Merge all would merge now; null once everything landed is merged. */
     runMergeView(): RunMergeView | null;
@@ -4050,7 +4344,15 @@ declare class Session {
     private requireSettledRun;
     /** Add the task that merges a conflicted task's branch by hand; see {@link PlanEditor.addConflictResolver}. */
     resolveConflictAsTask(taskId: string): Promise<LegacyPlanState | null>;
+    /**
+     * The user's Stop (ADR-0029): the run, and every start admitted before it —
+     * one queued behind a planner turn's edit, one waiting on its card, one
+     * still opening its run. A card still asking is cleared, so its start
+     * answers as stopped rather than waiting on a question that no longer stands.
+     */
     stopExecution(): void;
+    /** Something will start without being asked again; see {@link TaskOrchestrator.startsPending}. */
+    get startsPending(): boolean;
     /**
      * 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
@@ -4122,6 +4424,66 @@ declare class PlanEditError extends Error {
     constructor(message: string);
 }
 
+/** What the preflight reads: the planner choice and whatever it needs to be reachable. */
+type PlannerReadinessConfig = Pick<IConfig, 'aiProvider' | 'planningModel' | 'openaiCompatibleBaseUrl' | 'getProviderApiKey'>;
+/**
+ * Why the selected planner cannot plan yet, as data. Each surface words it with
+ * its own command spelling (`describePlannerNotReady`), so a daemon, a chat and
+ * a shell script can all say the same thing without sharing a syntax.
+ */
+type PlannerNotReady = {
+    code: 'no_key';
+    provider: AiProvider;
+    label: string;
+    keyEnvVar: string;
+} | {
+    code: 'no_base_url';
+    provider: AiProvider;
+    label: string;
+    baseUrlEnvVar: string;
+} | {
+    code: 'no_model';
+    provider: AiProvider;
+    label: string;
+};
+/**
+ * What the selected planner still needs before it can plan, or null when it is
+ * ready. There are two ways in (ADR-0009), and only one of them involves a
+ * credential: a harness planner drives a coding agent already installed on the
+ * machine, authenticated by the user's own subscription, so demanding an API
+ * key of it turns a working setup into a wall. Its model is optional too: an
+ * unset id means "the agent's own default".
+ */
+declare function plannerNotReady(config: PlannerReadinessConfig): PlannerNotReady | null;
+/**
+ * `plannerNotReady` judged on a host's own config — the one way every host
+ * builds the preflight's input, so none can hand it a key the selected
+ * planner's transport will not read (a stored OpenRouter key passing for an
+ * OpenAI planner, which then failed inside the transport). Every planner turn
+ * judges through this too, so none can let through what another refuses.
+ */
+declare function plannerNotReadyFor(config: Pick<IConfig, 'aiProvider' | 'orchestratorModel' | 'planningModel' | 'openaiCompatibleBaseUrl' | 'getProviderApiKey'>): PlannerNotReady | null;
+/** How one surface spells the commands a not-ready message points at. */
+interface PlannerCommandSyntax {
+    pickPlanner: string;
+    setKey(provider: AiProvider): string;
+    setModel: string;
+}
+declare const TERMINAL_UI_COMMANDS: PlannerCommandSyntax;
+/** The VS Code chat shares the terminal's slash commands, except that its `/model` needs `set`. */
+declare const CHAT_COMMANDS: PlannerCommandSyntax;
+declare const HEADLESS_CLI_COMMANDS: PlannerCommandSyntax;
+declare function describePlannerNotReady(reason: PlannerNotReady, commands: PlannerCommandSyntax): string;
+/**
+ * A planner turn refused before it began. Carries the reason as data so a
+ * client that spells commands differently (the headless CLI) can re-word it;
+ * the message is the terminal UI's spelling, which is what most clients show.
+ */
+declare class PlannerNotReadyError extends Error {
+    readonly reason: PlannerNotReady;
+    constructor(reason: PlannerNotReady);
+}
+
 /** What the user last picked for one planner backend. */
 interface PlannerModelChoice {
     model: string;
@@ -4197,6 +4559,8 @@ type DaemonErrorCode = 'session_not_found' | 'task_not_found' | 'no_plan' | 'alr
  | 'planner_turn_stopped'
 /** The planner turn settled after its plan was dropped; nothing it produced was kept. */
  | 'planner_turn_discarded'
+/** The selected planner cannot plan yet (no key, no base URL, no model); `plannerNotReady` says which. */
+ | 'planner_not_ready'
 /** The request asked for something the plan, task or conversation does not allow. */
  | 'refused' | 'checkpoint_not_waiting' | 'approval_not_outstanding';
 /** The body of every non-2xx answer a route gives. */
@@ -4205,6 +4569,8 @@ interface ErrorBody {
     code?: DaemonErrorCode;
     /** Set with `workspace_not_a_project`: the directory the daemon refused, so a client can offer to initialize it. */
     workspace?: string;
+    /** Set with `planner_not_ready`: the reason as data, so a client can word it in its own commands. */
+    plannerNotReady?: PlannerNotReady;
 }
 interface OkResponse {
     ok: boolean;
@@ -4323,8 +4689,8 @@ interface TaskLogResponse {
 type SessionListResponse = SessionMeta[];
 interface SettingsResponse {
     orchestratorModel: string;
-    /** Who plans (ADR-0009) — a vendor id, or one of the three harness planners. */
-    aiProvider: AiProvider;
+    /** Who plans (ADR-0009) — a vendor id, or a runner serving as a harness planner. */
+    aiProvider: PlannerBackendId;
     plannerThinkingEffort: string;
     maxParallel: number;
     modelAllowlist: UserSettings['modelAllowlist'];
@@ -4361,15 +4727,36 @@ interface ApprovalAnswerResponse extends OkResponse {
     granted: boolean;
     decision: ApprovalDecision['decision'];
 }
+/**
+ * Where a frame stands in its session's broadcast stream. A client holding
+ * several sockets on one session gets every broadcast on each, and a frame's
+ * content is no identity: two clears of a held edit are the same JSON. `seq`
+ * rises by one per broadcast of the session for as long as the daemon runs,
+ * whichever Session object holds the id; `stream` names the daemon process,
+ * so a restarted daemon's numbering is never compared with the last one's.
+ */
+interface StreamStamp {
+    stream: string;
+    seq: number;
+}
+/** A broadcast as the session's socket carries it. Unstamped from a daemon older than the stamp. */
+type SessionFrame = (SessionMessage | SessionNotice) & Partial<StreamStamp>;
+type ApprovalRequestMessage = Extract<SessionMessage, {
+    type: 'approval_request';
+}>;
 /**
  * What a session's socket sends right after `connected`: its run as it stands,
- * so a client that joins mid-run has the run view before the next update.
- * Every frame after it is a `SessionMessage` or `SessionNotice`.
+ * so a client that joins mid-run has the run view before the next update —
+ * the held edit's preview included — and the planner's approval requests
+ * still waiting, which no later frame would announce again. `seq` is the last
+ * broadcast it accounts for. Every frame after it is a {@link SessionFrame}.
  */
-interface RunSnapshotFrame {
+interface RunSnapshotFrame extends Partial<StreamStamp> {
     type: 'run_snapshot';
     sessionId: string;
     view: RunView;
+    /** Absent from a daemon older than the field: nothing is known, not "none waiting". */
+    approvals?: ApprovalRequestMessage[];
 }
 
 /**
@@ -5180,13 +5567,17 @@ declare function savePrdMarkdown(workspace: string, slug: string, markdown: stri
 
 /** Who plans, with which model and effort. Blank means unset. */
 interface PlannerSelectionState {
-    provider: AiProvider;
+    provider: PlannerBackendId;
     model: string;
     effort: string;
 }
+/** The state a change is judged against, and where its model came from; absent means the user's own. */
+interface PlannerSelectionCurrent extends PlannerSelectionState {
+    source?: PlannerModelSource;
+}
 /** What one user action asked for; an absent field leaves that part alone. */
 interface PlannerSelectionChange {
-    provider?: AiProvider;
+    provider?: PlannerBackendId;
     model?: string;
     effort?: string;
 }
@@ -5204,7 +5595,7 @@ type PlannerModelLookup = Pick<PlannerModelStore, 'getPlannerModel'>;
  * effect after the change, and writes back what this returns. It never
  * stores anything itself, so each surface keeps only its storage adapter.
  */
-declare function selectPlanner(current: PlannerSelectionState, change: PlannerSelectionChange, memory: PlannerModelLookup, catalog: PlannerModelCandidate[]): PlannerSelectionResult;
+declare function selectPlanner(current: PlannerSelectionCurrent, change: PlannerSelectionChange, memory: PlannerModelLookup, catalog: PlannerModelCandidate[]): PlannerSelectionResult;
 
 /** How many AI tasks may run at once: `ORDEWELL_MAX_PARALLEL`, `/parallel`, `ordewell.maxParallelSessions`. */
 declare const DEFAULT_MAX_PARALLEL = 5;
@@ -5216,4 +5607,4 @@ declare const DEFAULT_MAX_PARALLEL = 5;
  */
 declare function parseMaxParallel(value: unknown): number | null;
 
-export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, type AdoptSessionResponse, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApplyTaskOpsResult, ApprovalAnswer, type ApprovalAnswerResponse, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, ApprovalRequest, type ApprovalsResponse, type AskOptions, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CancelPlanningResponse, type CancelResumeResponse, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, CodexSandboxAvailability, type CommandDescriptor, CommandLineTooLongError, type CommandOutcome, type CommandsResponse, type Consent, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompactResponse, type ConversationCompaction, ConversationEditError, type ConversationFork, type ConversationForkResponse, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationRewindResponse, type ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, DEFAULT_WEB_READ_BUDGET, type DaemonErrorCode, type DecideOptions, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ErrorBody, type ExecImpl, ExecutableNotFoundError, type ExecuteResponse, ExecutionActor, type ExecutionCommand, ExecutionCommandName, ExecutionCommands, type ExecutionHost, ExecutionRecord, FindSymbolOptions, type ForceSendResponse, GREP_PCRE_PROBE_ARGS, GeminiService, type GeneratePlanResponse, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, GuardTarget, GuardTrip, HARNESS_PLANNER_REASON, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, type IsolationDiffResponse, IsolationLandedTask, type IsolationMergeResponse, IsolationMergeResult, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, type LiveOutputLookup, LiveTail, LiveTailOptions, type LoopGuard, type MappedTool, type MergeGateEntry, type MergeGateResponse, ModelResolver, type ModelResolverDeps, type ModelsResponse, NoPlanError, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, type OkResponse, OpenAiService, OpenCodeAdapter, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, type PlanRequest, type PlanResponse, PlanState, PlanStore, Planner, type PlannerBackendEntry, type PlannerModelCandidate, type PlannerModelChoice, type PlannerModelLookup, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerSelectionChange, type PlannerSelectionResult, type PlannerSelectionState, type PlannerSubmission, PlannerToolHandler, PlannerTurnDiscardedError, PlannerTurnStoppedError, type PlannerUsability, PlannerUsage, type PrdBlock, type PrdResponse, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, type RemoveMessageResponse, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolveConflictResponse, type RewindTarget, type RewindTargetsResponse, RunMergeView, type RunSnapshotFrame, RunView, RunnerApprovals, RunnerCommand, RunnerId, RunnerInstallation, RunnerManifest, RunnerModeInfo, RunnerRegistry, type RunnerSpawnOptions, type RunnersResponse, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SUPERVISOR_LEVELS, SYMBOL_LANGUAGES, type SaveSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionListResponse, SessionMessage, type SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionResponse, type SessionRuntimeSettings, type SettingsResponse, type SettingsUpdateResponse, SkillInfo, type SkillInvocation, SkillLoad, SkillsService, type SpawnSpec, StdioAgentAdapter, type StopResponse, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, SupervisorLevel, type SupervisorPolicy, SurfacePlan, SurfacePlanState, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, Task, TaskCompleteArgs, type TaskLogAttemptsResponse, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, type TaskLogResponse, TaskMessageFrom, type TaskMessageResponse, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WebRead, type WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorkspacesResponse, type WorktreeIsolationDeps, abbreviateHome, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexSandboxNotice, configuredProviders, continuability, createAiService, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, describeMergeResult, discoverGeminiModels, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, formatSearchOutput, getLatestSession, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseSearchHits, parseTaskQueryJson, planDirectLaunch, plannerBackendEntries, plannerMessage, plannerTranscript, prefixModelId, providerForRunner, readDaemonToken, readTaskLog, referencePattern, removedPluginNotice, renderTaskQueryAnswer, resolveProviderFromPrefix, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, selectPlanner, sessionDataDir, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, taskQuerySignature, textHasTaskQuery, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writePrivateFile };
+export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, type AdoptSessionResponse, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApplyTaskOpsResult, ApprovalAnswer, type ApprovalAnswerResponse, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, ApprovalRequest, type ApprovalRequestMessage, type ApprovalsResponse, type AskOptions, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, type ByPlannerBackend, CHAT_COMMANDS, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CancelPlanningResponse, type CancelResumeResponse, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, CodexSandboxAvailability, type CommandDescriptor, CommandLineTooLongError, type CommandOutcome, type CommandsResponse, type ConfiguredPlanner, type Consent, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompactResponse, type ConversationCompaction, ConversationEditError, type ConversationFork, type ConversationForkResponse, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationRewindResponse, type ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, DEFAULT_WEB_READ_BUDGET, type DaemonErrorCode, type DecideOptions, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ErrorBody, type ExecImpl, ExecutableNotFoundError, type ExecuteResponse, ExecutionActor, type ExecutionCommand, ExecutionCommandName, ExecutionCommands, type ExecutionHost, ExecutionRecord, FindSymbolOptions, type ForceSendResponse, GREP_PCRE_PROBE_ARGS, GeminiService, type GeneratePlanResponse, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, GuardTarget, GuardTrip, HARNESS_PLANNER_REASON, HEADLESS_CLI_COMMANDS, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, type IsolationDiffResponse, IsolationLandedTask, type IsolationMergeResponse, IsolationMergeResult, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, type LiveOutputLookup, LiveTail, LiveTailOptions, type LoopGuard, type MappedTool, type MergeGateEntry, type MergeGateResponse, ModelResolver, type ModelResolverDeps, type ModelsResponse, NoPlanError, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, type OkResponse, OpenAiService, OpenCodeAdapter, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, type PlanRequest, type PlanResponse, PlanState, PlanStatus, PlanStore, Planner, type PlannerBackendEntry, PlannerBackendId, type PlannerChoice, type PlannerCommandSyntax, type PlannerModelCandidate, type PlannerModelChoice, type PlannerModelLookup, PlannerModelMemory, type PlannerModelRecall, type PlannerModelSource, type PlannerModelStore, type PlannerNotReady, PlannerNotReadyError, type PlannerReadinessConfig, type PlannerSelectionChange, type PlannerSelectionCurrent, type PlannerSelectionResult, type PlannerSelectionState, type PlannerSubmission, PlannerToolHandler, PlannerTurnDiscardedError, PlannerTurnStoppedError, type PlannerUsability, PlannerUsage, type PrdBlock, type PrdResponse, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, type RemoveMessageResponse, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolveConflictResponse, type ResolvedChoice, type ResolvedPlanner, type RewindTarget, type RewindTargetsResponse, RunMergeView, type RunSnapshotFrame, RunView, RunnerApprovals, RunnerCommand, RunnerId, RunnerInstallation, RunnerManifest, RunnerModeInfo, RunnerRegistry, type RunnerSpawnOptions, type RunnersResponse, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SUPERVISOR_LEVELS, SYMBOL_LANGUAGES, type SaveSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionFrame, type SessionListResponse, SessionMessage, type SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionResponse, type SessionRuntimeSettings, type SettingsResponse, type SettingsUpdateResponse, SkillInfo, type SkillInvocation, SkillLoad, SkillsService, type SpawnSpec, StartAdmission, StdioAgentAdapter, type StopResponse, type StreamStamp, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, SupervisorLevel, type SupervisorPolicy, SurfacePlan, SurfacePlanState, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TERMINAL_UI_COMMANDS, Task, TaskCompleteArgs, type TaskLogAttemptsResponse, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, type TaskLogResponse, TaskMessageFrom, type TaskMessageResponse, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WebRead, type WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorkspacesResponse, type WorktreeIsolationDeps, abbreviateHome, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexSandboxNotice, configuredProviders, continuability, createAiService, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultEnabledRunners, defaultLogger, definitionPattern, deleteSession, describeMergeResult, describePlannerNotReady, detectInstalledPlanner, discoverGeminiModels, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, findInstalledPlanner, formatSearchOutput, getLatestSession, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, installedPlannerAnswered, installedPlannerDetected, isApiProvider, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlannerBackend, isVendorModelFor, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseSearchHits, parseTaskQueryJson, planDirectLaunch, plannerBackendEntries, plannerMessage, plannerNotReady, plannerNotReadyFor, plannerTranscript, prefixModelId, providerForRunner, readDaemonToken, readTaskLog, recordInstalledPlanner, recordedInstalledPlanner, referencePattern, removedPluginNotice, renderTaskQueryAnswer, resetInstalledPlanner, resolveProviderFromPrefix, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, selectPlanner, sessionDataDir, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, taskQuerySignature, textHasTaskQuery, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writePrivateFile };