@ordewell/core 0.10.3 → 0.10.5

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-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.js';
-export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, D as DEFAULT_RUNNERS, c as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as IntegrationDisposal, i as InvalidSkill, j as IsolationAvailability, k as IsolationHandoff, l as IsolationHandoffRepo, m as IsolationInactiveReason, o as IsolationLanding, p as IsolationMergeBlock, q as IsolationMergeBlockReason, s as IsolationOutcome, t as IsolationPruneResult, u as IsolationRemoval, v as IsolationRepo, w as IsolationRun, x as IsolationTaskRecord, y as IsolationTaskRef, z as IsolationTaskRepo, M as ModelUsage, O as PlanUsage, R as PrepareIntent, S as PreparedTask, T as PreservedWork, U as PreviousWork, V as RefusedRemoval, W as RepairEvidence, X as RepoGroupLayout, _ as ResearchStep, $ as ResearchStepOutcome, a1 as RunSettings, a3 as SetupFailure, a4 as ShadowedSkill, a5 as SkillAppliesTo, a6 as SkillCatalog, a9 as SkillLoadNotice, aa as SkillMetadata, ab as SkillSource, ai as TaskIsolation, aj as TaskIsolationState, ak as TaskModelAssignment, ao as TaskStatus, ap as TreeSnapshot, aq as UsageLine, as as UsageTotals, au as VerificationCheck, av as addAttemptUsage, aw as addModelUsage, ax as addPlannerUsage, ay as addUsage, az as addUsageTotals, aA as createEmptyPlan, aB as createSkillsService, aC as createTask, aD as endAttemptUsage, aE as flattenTasks, aF as flattenTasksWithParents, aG as isAwaitingReason, aH as isMeasured, aI as isSupervisorLevel, aJ as isUserMessage, aK as migratePlanState, aL as partedPromptUsage, aM as pausedOnLimit, aN as planUsage, aO as plannerContextFill, aP as rejoinPlanTree, aQ as startAttemptUsage, aR as usageLine, aS as waitsForApproval } from './Task-CRVIqSfy.js';
-import { ah as StartAdmission, w as LiveTailOptions, L as LiveTail, U as PlannerModes, at as TaskOp, u as IsolatedExecution, aa as SessionBroadcaster, b as ApplyTaskOpsResult, af as SkillLookup, ac as SessionNotice, q as EditCatalog, ab as SessionMessage, T as PlanStore, au as TaskOrchestrator, v as IsolationRunController, O as OrchestratorObserver, ar as TaskLogEvent, I as INotification, s as GlobalRunSettings, a1 as RunView, Z as RunMergeView, ax as TaskOutputSource, aO as UserSettings, al as SurfacePlan, am as SurfacePlanState } from './plan-utils-oC8bO4pN.js';
-export { A as ACT_RISK, a as AUTORUN_RISK, c as ApprovalBlock, d as ApprovalStatus, e as AutoMergeTrigger, B as BlockingSubject, C as CHECKPOINT_TRUNCATE_LENGTH, f as CommandBlock, g as CommandStatus, h as CompactionBlock, i as ConversationInput, j as ConversationView, D as DiffRow, k as DiffRowKind, l as DiffStat, m as DisplayBlock, E as EMPTY_CONVERSATION, n as EMPTY_HOLD, o as EMPTY_RUN, p as EMPTY_TASK_LOG, r as ExecutionSummary, G as GatedConversation, H as HeldEdit, t as HeldEditMark, x as LocalEntry, M as MarkdownToken, y as MessageBlock, z as MessageRole, N as NOT_STARTED, F as NO_TURN, J as NewTaskFields, K as NotificationAction, P as OutputPreview, Q as PlanBlock, R as PlanMarkerStatus, S as PlanSnapshot, V as PromptHold, W as RUN_SETTINGS_DEFAULTS, Y as RunInput, _ as RunSettingsError, $ as RunTask, a0 as RunTaskStatus, a2 as RunnerLoadedBlock, a3 as STOPPED_BEFORE_START, a4 as SUPERVISOR_LEVEL_LABEL, a5 as SerializedConversationMessage, a6 as SerializedPendingTurn, a7 as SerializedPlan, a8 as SerializedTask, a9 as SerializedTaskStatus, ad as SettingsService, ae as SkillLoadBlock, ag as SkillToken, ai as SubagentBlock, aj as SubagentChild, ak as SubagentStatus, an as SurfaceTask, ao as TakenPrompt, ap as TaskAttemptSnapshot, aq as TaskControlError, as as TaskLogView, av as TaskOrchestratorDeps, aw as TaskOrchestratorOptions, ay as TaskRef, az as TaskRowAction, aA as TaskRowContext, aB as TaskRowIsolation, aC as TaskRowKind, aD as TaskRowPlacement, aE as TaskRowSubject, aF as TaskRowUsage, aG as TaskRowView, aH as TaskStatusKind, aI as ThinkingDisplayBlock, aJ as ToolBlock, aK as ToolHeadline, aL as ToolStatus, aM as TurnGate, aN as UsageBlock, aP as WAITS_FOR_APPROVAL_LABEL, aQ as aheadOfDraft, aR as applyTaskOps, aS as approvalLabel, aT as automergeSummary, aU as autorunSummary, aV as awaitingLabel, aW as blockedByLabel, aX as blockingFailures, aY as canMergeTasks, aZ as canSetDependencies, a_ as canSplitTask, a$ as capConflictFiles, b0 as classifyOutcome, b1 as coalesceTaskLog, b2 as dependencyCandidates, b3 as dependentsNotice, b4 as dependentsOf, b5 as diffRows, b6 as diffStat, b7 as diffSummary, b8 as digestTaskLog, b9 as drainNext, ba as executionSummary, bb as followTurn, bc as fromTranscript, bd as getSettingsPath, be as hasHiddenDetail, bf as holdPrompt, bg as isTaskRunning, bh as loadedSkillTokens, bi as markAction, bj as markRequestFor, bk as markdownHtml, bl as markdownTokens, bm as namedRepos, bn as newTaskFields, bo as opsEditable, bp as outputLines, bq as outputPreview, br as parseCount, bs as parseSwitch, bt as parseTaskOpsJson, bu as pastGateConfirmation, bv as reconcileApprovals, bw as reduceConversation, bx as reduceRun, by as reduceTaskLog, bz as replayTaskLog, bA as resolveTaskRef, bB as resumeLabel, bC as resumeTime, bD as runSettingsOf, bE as runnerToolSubject, bF as serializePlan, bG as serializeTask, bH as serializeTaskStatus, bI as skillTokens, bJ as skippedLabel, bK as stopTurn, bL as summarizeToolCall, bM as supervisorSummary, bN as surfacePlan, bO as surfacePlanState, bP as takeAt, bQ as taskLogForSurface, bR as taskOrderLabel, bS as taskRef, bT as taskRefOf, bU as taskRowActions, bV as taskRowView, bW as taskStartedNotice, bX as taskStatusKind, bY as textHasTaskOps, bZ as titledRefs, b_ as titledTaskRef, b$ as titledTaskRefOf, c0 as toTaskLogEvent, c1 as toolHeadline, c2 as trimToolOutput, c3 as truncateCheckpointSummary, c4 as unsendAll, c5 as unsendLatest } from './plan-utils-oC8bO4pN.js';
-import { I as IApproval, y as IConfig, d as AgentProcessDeps, a as AgentAdapter, _ as OrdewellMcpServer, a6 as PlannerToolHandler, ad as ResearchShell, p as ApprovalRequest, j as ApprovalDecision, i as ApprovalAnswer, z as IRunner, a3 as PlannerBackendId, a9 as ProviderModelLists, f as AiProvider, m as ApprovalModeSetting, aq as RunnerRegistry, Z as OrchestratorOption, aD as TaskModeAgentAdapter, e as AgentStartOptions, c as AgentEvent, ai as RunnerCommand, a7 as ProjectMcpServer, n as ApprovalPolicy, B as IRunnerSession, aA as TaskCompleteArgs, r as CheckpointAnswer, av as StructuredTurnEnd, au as StructuredEvent, aC as TaskMessageFrom, ab as QueuedTaskMessage, aI as TaskStartOptions, aJ as TaskTokenScope, am as RunnerManifest, aH as TaskRunnerFlags } from './IRunner-QBdYcatb.js';
-export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, k as ApprovalKind, l as ApprovalMode, o as ApprovalPolicyOptions, q as ApprovalSource, C as CatalogModel, s as CheckpointArgs, t as CommandClassification, u as CommandTier, v as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, w as DENY_ALL, x as DiscoveryCommand, E as EditPlanArgs, F as FetchAllProviderModelsOptions, G as GIT_READONLY_SUBCOMMANDS, H as InvokedCommand, L as LineBuffer, J as ListModelsArgs, K as ListRunnersArgs, M as LoadSkillArgs, N as McpClientConfig, O as McpCredential, P as McpTool, Q as McpToolContext, R as McpToolReply, S as MessageTaskArgs, T as ModelCatalog, U as ModelShortcut, V as ORCHESTRATOR_SHORTCUTS, W as ORDEWELL_MCP_PATH, X as ORDEWELL_MCP_SERVER_NAME, Y as OneTaskArgs, $ as OwnerOnlyFile, a0 as PLANNER_EXECUTION_TOOLS, a1 as PLANNER_TOOLS, a2 as PlannerAllowlist, a4 as PlannerStartOptions, a5 as PlannerTokenScope, a8 as ProviderCredentialSource, aa as ProviderModelsResult, ac as REFUSED_COMMANDS, ae as ResearchShellDeps, af as RetryTaskArgs, ag as RunCommandArgs, ah as RunPlanArgs, aj as RunnerCommandKind, ak as RunnerEntry, al as RunnerFeatures, an as RunnerMcpServer, ao as RunnerMode, ap as RunnerModelDiscovery, ar as ShellDialect, as as SpawnFn, at as StandingDecision, aw as SubmitPlanArgs, ax as TASK_COMPLETE_TOOL, ay as TASK_COMPLETION_CONTRACT, az as TASK_TOOLS, aB as TaskDiffArgs, aE as TaskModeUnsupportedError, aF as TaskOutputArgs, aG as TaskQueryArgs, aK as TaskToolHandler, aL as approvalScopes, aM as classifyCommand, aN as clearResearchShellCache, aO as collectProviderCredentials, aP as commandAllowedBy, aQ as effectiveApprovalMode, aR as enabledRunners, aS as fetchAllProviderModels, aT as findRunnerCommand, aU as isGranted, aV as isRunnerApproval, aW as knownModelId, aX as mcpClientConfig, aY as ownerOnlyConfigFile, aZ as parseAllowlist, a_ as parseApprovalModeSetting, a$ as researchShellWarning, b0 as researchToolsPath, b1 as resolveModelShortcut, b2 as resolveProvider, b3 as resolveResearchShell, b4 as scopeAllowed, b5 as sharedMcpServer, b6 as toApprovalDecision, b7 as toOrchestratorOptions, b8 as toolAllowed } from './IRunner-QBdYcatb.js';
-import { T as ToolOutcome, I as IFileSystem, R as ReadFileOpts, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-DCd-rkeH.js';
-export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-DCd-rkeH.js';
-import { R as RunnerModeInfo } from './ModeResolver-BOU90Nn-.js';
-export { a as autonomyLevelLabel, p as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-BOU90Nn-.js';
+import { ah as Task, E as ExecutionActor, r as IsolationMergeResult, f as ExecutionRecord, g as GuardTrip, ag as SupervisorLevel, e as ExecutionCommandName, G as GuardTarget, a3 as RunnerId, d as DiscoveredModel, _ as ResearchProgress, Z as ResearchLogEntry, C as ConversationMessage, a9 as SkillInfo, aa as SkillLoad, ae as SkillsService, L as LegacyPlanState, N as PlanStatus, n as IsolationLandedTask, I as IWorktreeIsolation, F as IsolationTaskStatus, J as PlanIsolation, au as UsageRecord, a4 as RunnerSessionCost, a1 as ResearchToolType, R as PlannerUsage, ao as TaskSkillSnapshot, ap as TaskSnapshot, K as PlanState, H as IsolationView, aw as Verdict } from './Task-D4QHjdGv.js';
+export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, D as DEFAULT_RUNNERS, c as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as IntegrationDisposal, i as InvalidSkill, j as IsolationAvailability, k as IsolationHandoff, l as IsolationHandoffRepo, m as IsolationInactiveReason, o as IsolationLanding, p as IsolationMergeBlock, q as IsolationMergeBlockReason, s as IsolationOutcome, t as IsolationPruneResult, u as IsolationRemoval, v as IsolationRepo, w as IsolationRun, x as IsolationTaskRecord, y as IsolationTaskRef, z as IsolationTaskRepo, M as ModelUsage, O as PlanUsage, Q as PlannerResendState, S as PrepareIntent, T as PreparedTask, U as PreservedWork, V as PreviousWork, W as RefusedRemoval, X as RepairEvidence, Y as RepoGroupLayout, $ as ResearchStep, a0 as ResearchStepOutcome, a2 as RunSettings, a5 as SetupFailure, a6 as ShadowedSkill, a7 as SkillAppliesTo, a8 as SkillCatalog, ab as SkillLoadNotice, ac as SkillMetadata, ad as SkillSource, ak as TaskIsolation, al as TaskIsolationState, am as TaskModelAssignment, aq as TaskStatus, ar as TaskUsageSummary, as as TreeSnapshot, at as UsageLine, av as UsageTotals, ax as VerificationCheck, ay as addAttemptUsage, az as addModelUsage, aA as addPlannerUsage, aB as addUsage, aC as addUsageTotals, aD as countedSessionCost, aE as createEmptyPlan, aF as createSkillsService, aG as createTask, aH as endAttemptUsage, aI as flattenTasks, aJ as flattenTasksWithParents, aK as isAwaitingReason, aL as isMeasured, aM as isSupervisorLevel, aN as isUserMessage, aO as migratePlanState, aP as partedPromptUsage, aQ as pausedOnLimit, aR as planUsage, aS as plannerContextFill, aT as rejoinPlanTree, aU as resumedSessionWindow, aV as startAttemptUsage, aW as taskUsageSummary, aX as usageLine, aY as waitsForApproval } from './Task-D4QHjdGv.js';
+import { aj as StartAdmission, y as LiveTailOptions, L as LiveTail, W as PlannerModes, av as TaskOp, w as IsolatedExecution, f as AssignmentScope, ac as SessionBroadcaster, b as ApplyTaskOpsResult, ah as SkillLookup, ae as SessionNotice, s as EditCatalog, ad as SessionMessage, V as PlanStore, aw as TaskOrchestrator, x as IsolationRunController, Q as OrchestratorObserver, at as TaskLogEvent, I as INotification, u as GlobalRunSettings, a3 as RunView, $ as RunMergeView, az as TaskOutputSource, aQ as UserSettings, an as SurfacePlan, ao as SurfacePlanState } from './plan-utils-BVJCzNvm.js';
+export { A as ACT_RISK, a as AUTORUN_RISK, c as ApprovalBlock, d as ApprovalStatus, e as AssignmentIssue, g as AutoMergeTrigger, B as BlockingSubject, C as CHECKPOINT_TRUNCATE_LENGTH, h as CommandBlock, i as CommandStatus, j as CompactionBlock, k as ConversationInput, l as ConversationView, D as DiffRow, m as DiffRowKind, n as DiffStat, o as DisplayBlock, E as EMPTY_CONVERSATION, p as EMPTY_HOLD, q as EMPTY_RUN, r as EMPTY_TASK_LOG, t as ExecutionSummary, G as GatedConversation, H as HeldEdit, v as HeldEditMark, z as LocalEntry, M as MarkdownToken, F as MessageBlock, J as MessageRole, N as NOT_STARTED, K as NO_TURN, O as NewTaskFields, P as NotificationAction, R as OutputPreview, S as PlanBlock, T as PlanMarkerStatus, U as PlanSnapshot, X as PromptHold, Y as RUN_SETTINGS_DEFAULTS, _ as RunInput, a0 as RunSettingsError, a1 as RunTask, a2 as RunTaskStatus, a4 as RunnerLoadedBlock, a5 as STOPPED_BEFORE_START, a6 as SUPERVISOR_LEVEL_LABEL, a7 as SerializedConversationMessage, a8 as SerializedPendingTurn, a9 as SerializedPlan, aa as SerializedTask, ab as SerializedTaskStatus, af as SettingsService, ag as SkillLoadBlock, ai as SkillToken, ak as SubagentBlock, al as SubagentChild, am as SubagentStatus, ap as SurfaceTask, aq as TakenPrompt, ar as TaskAttemptSnapshot, as as TaskControlError, au as TaskLogView, ax as TaskOrchestratorDeps, ay as TaskOrchestratorOptions, aA as TaskRef, aB as TaskRowAction, aC as TaskRowContext, aD as TaskRowIsolation, aE as TaskRowKind, aF as TaskRowPlacement, aG as TaskRowSubject, aH as TaskRowUsage, aI as TaskRowView, aJ as TaskStatusKind, aK as ThinkingDisplayBlock, aL as ToolBlock, aM as ToolHeadline, aN as ToolStatus, aO as TurnGate, aP as UsageBlock, aR as WAITS_FOR_APPROVAL_LABEL, aS as aheadOfDraft, aT as applyTaskOps, aU as approvalLabel, aV as assignmentIssue, aW as assignmentIssueText, aX as automergeSummary, aY as autorunSummary, aZ as awaitingLabel, a_ as blockedByLabel, a$ as blockingFailures, b0 as canMergeTasks, b1 as canSetDependencies, b2 as canSplitTask, b3 as capConflictFiles, b4 as classifyOutcome, b5 as coalesceTaskLog, b6 as dependencyCandidates, b7 as dependentsNotice, b8 as dependentsOf, b9 as diffRows, ba as diffStat, bb as diffSummary, bc as digestTaskLog, bd as drainNext, be as executionSummary, bf as followTurn, bg as fromTranscript, bh as getSettingsPath, bi as hasHiddenDetail, bj as holdPrompt, bk as isTaskRunning, bl as loadedSkillTokens, bm as markAction, bn as markRequestFor, bo as markdownHtml, bp as markdownTokens, bq as namedRepos, br as newTaskFields, bs as opsEditable, bt as outputLines, bu as outputPreview, bv as parseCount, bw as parseSwitch, bx as parseTaskOpsJson, by as pastGateConfirmation, bz as reconcileApprovals, bA as reduceConversation, bB as reduceRun, bC as reduceTaskLog, bD as replayTaskLog, bE as resolveTaskRef, bF as resumeLabel, bG as resumeTime, bH as runSettingsOf, bI as runnerToolSubject, bJ as serializePlan, bK as serializeTask, bL as serializeTaskStatus, bM as skillTokens, bN as skippedLabel, bO as stopTurn, bP as summarizeToolCall, bQ as supervisorSummary, bR as surfacePlan, bS as surfacePlanState, bT as takeAt, bU as taskLogForSurface, bV as taskOrderLabel, bW as taskRef, bX as taskRefOf, bY as taskRowActions, bZ as taskRowView, b_ as taskStartedNotice, b$ as taskStatusKind, c0 as textHasTaskOps, c1 as titledRefs, c2 as titledTaskRef, c3 as titledTaskRefOf, c4 as toTaskLogEvent, c5 as toolHeadline, c6 as trimToolOutput, c7 as truncateCheckpointSummary, c8 as unsendAll, c9 as unsendLatest } from './plan-utils-BVJCzNvm.js';
+import { I as IApproval, y as IConfig, d as AgentProcessDeps, a as AgentAdapter, _ as OrdewellMcpServer, aM as UsageLimitSignal, 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, ar as RunnerRegistry, Z as OrchestratorOption, aE as TaskModeAgentAdapter, e as AgentStartOptions, c as AgentEvent, ai as RunnerCommand, a7 as ProjectMcpServer, B as IRunnerSession, n as ApprovalPolicy, aB as TaskCompleteArgs, r as CheckpointAnswer, aw as StructuredTurnEnd, av as StructuredEvent, aD as TaskMessageFrom, ab as QueuedTaskMessage, aJ as TaskStartOptions, aK as TaskTokenScope, am as RunnerManifest, aI as TaskRunnerFlags } from './IRunner-Crkt3tHD.js';
+export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, k as ApprovalKind, l as ApprovalMode, o as ApprovalPolicyOptions, q as ApprovalSource, C as CatalogModel, s as CheckpointArgs, t as CommandClassification, u as CommandTier, v as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, w as DENY_ALL, x as DiscoveryCommand, E as EditPlanArgs, F as FetchAllProviderModelsOptions, G as GIT_READONLY_SUBCOMMANDS, H as InvokedCommand, L as LineBuffer, J as ListModelsArgs, K as ListRunnersArgs, M as LoadSkillArgs, N as McpClientConfig, O as McpCredential, P as McpTool, Q as McpToolContext, R as McpToolReply, S as MessageTaskArgs, T as ModelCatalog, U as ModelShortcut, V as ORCHESTRATOR_SHORTCUTS, W as ORDEWELL_MCP_PATH, X as ORDEWELL_MCP_SERVER_NAME, Y as OneTaskArgs, $ as OwnerOnlyFile, a0 as PLANNER_EXECUTION_TOOLS, a1 as PLANNER_TOOLS, a2 as PlannerAllowlist, a4 as PlannerStartOptions, a5 as PlannerTokenScope, a8 as ProviderCredentialSource, aa as ProviderModelsResult, ac as REFUSED_COMMANDS, ae as ResearchShellDeps, af as RetryTaskArgs, ag as RunCommandArgs, ah as RunPlanArgs, aj as RunnerCommandKind, ak as RunnerEntry, al as RunnerFeatures, an as RunnerMcpServer, ao as RunnerMode, ap as RunnerModelDiscovery, aq as RunnerModelRef, as as ShellDialect, at as SpawnFn, au as StandingDecision, ax as SubmitPlanArgs, ay as TASK_COMPLETE_TOOL, az as TASK_COMPLETION_CONTRACT, aA as TASK_TOOLS, aC as TaskDiffArgs, aF as TaskModeUnsupportedError, aG as TaskOutputArgs, aH as TaskQueryArgs, aL as TaskToolHandler, aN as approvalScopes, aO as classifyCommand, aP as clearResearchShellCache, aQ as collectProviderCredentials, aR as commandAllowedBy, aS as effectiveApprovalMode, aT as enabledRunners, aU as fetchAllProviderModels, aV as findRunnerCommand, aW as isGranted, aX as isRunnerApproval, aY as knownModelId, aZ as mcpClientConfig, a_ as ownerOnlyConfigFile, a$ as parseAllowlist, b0 as parseApprovalModeSetting, b1 as researchShellWarning, b2 as researchToolsPath, b3 as resolveModelShortcut, b4 as resolveProvider, b5 as resolveResearchShell, b6 as scopeAllowed, b7 as sharedMcpServer, b8 as toApprovalDecision, b9 as toOrchestratorOptions, ba as toolAllowed } from './IRunner-Crkt3tHD.js';
+import { T as ToolOutcome, I as IFileSystem, R as ReadFileOpts, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-ClBdp59f.js';
+export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-ClBdp59f.js';
+import { R as RunnerModeInfo } from './ModeResolver-CUR5jCSU.js';
+export { a as autonomyLevelLabel, p as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-CUR5jCSU.js';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
 import 'zod/v4';
@@ -125,6 +125,8 @@ interface ExecutionHost {
     planApproved(): boolean;
     /** The user approved this task: it was in the plan they executed, or they started it themselves. */
     taskApproved(taskId: string): boolean;
+    /** A task the scheduler leaves for the user to approve: added to the plan since they approved it (ADR-0035). */
+    waitsForApproval(taskId: string): boolean;
     /** A start the user consented to approves these tasks, before it acts. */
     approve(taskIds: readonly string[]): void;
     /** Full autonomy: starts follow plan approval without a question. */
@@ -156,6 +158,12 @@ interface ExecutionHost {
     waitingRequests(taskId: string): readonly WaitingRequest[];
     /** A start is told who asked: whether a run it opens continues the last one depends on it (ADR-0029). */
     runPlan(actor: ExecutionActor): Promise<void>;
+    /**
+     * The user's Execute while a run is under way, once it approved every task:
+     * the run takes them in, each starting once its dependencies finish. Answers
+     * the line that says so, naming how many had waited for approval.
+     */
+    joinRun(approved: number): Promise<string>;
     startTask(taskId: string, actor: ExecutionActor): Promise<void>;
     stopTask(taskId: string): Promise<void>;
     stopRun(): void;
@@ -680,12 +688,6 @@ interface ConversationRequest {
     fetcher?: IWebFetcher;
     runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     autonomousDefault?: boolean;
-    /**
-     * The planner model's context window when the catalog knows it. Threaded here
-     * so a usage record can carry it (and the UI can show context fill); absent
-     * when unknown, never guessed (#49).
-     */
-    contextWindow?: number;
     /** Where tasks will run (ADR-0013, ADR-0014): in worktrees, the prompt drops file-overlap ordering and describes a repo group. */
     isolatedExecution?: IsolatedExecution;
     /** A plan the planner submits starts at once (ADR-0030), so the opening prompt has no outline gate. */
@@ -730,7 +732,8 @@ type ConversationTurn =
 /**
  * `aborted`: the call was stopped, and `text` is only what it had by then.
  * `failed`: the call ended without a reply (a dead agent, a usage limit),
- * and `text` says why.
+ * and `text` says why; `usageLimit`, where the runner also said in a field
+ * whether that was its usage limit (see {@link TurnFailure}).
  */
 {
     kind: 'message';
@@ -738,6 +741,7 @@ type ConversationTurn =
     researchLog: ResearchLogEntry[];
     aborted?: boolean;
     failed?: boolean;
+    usageLimit?: UsageLimitSignal | false;
 } | {
     kind: 'plan';
     tasks: Task[];
@@ -874,9 +878,35 @@ declare function plannerMessage(text: string, loads: readonly SkillLoad[]): stri
  * carries the skills loaded after it, composed by {@link plannerMessage}, and
  * the load entries themselves are folded away. Sessions saved before skill
  * loads existed hold the expanded text in the message and replay unchanged.
+ * A failed turn's entry is left out: the planner never said it.
  */
 declare function plannerTranscript(history: readonly ConversationMessage[]): ConversationMessage[];
 
+/**
+ * What a stopped runner says about why it stopped, and what ending an attempt
+ * does to the runner it leaves behind. TaskOrchestrator acts on the answers.
+ */
+
+/**
+ * A turn's failure as its runner reported it: its words, and `usageLimit`
+ * where its protocol also says in a field whether it was the limit (Codex's
+ * `codexErrorInfo`).
+ */
+interface TurnFailure {
+    message: string;
+    usageLimit?: UsageLimitSignal | false;
+}
+
+/** What a usage limit that ended a planner turn led to. */
+interface PlannerLimit {
+    /** The line the transcript keeps, drawn as a failure. */
+    text: string;
+    /** When what the turn took goes again on its own; null when it waits for the user's next message. */
+    resendAt: Date | null;
+    /** Why nothing goes again on its own, when nothing does: what the planner did, as in "the planner hit its usage limit and …". */
+    held?: string;
+}
+
 /**
  * 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
@@ -947,6 +977,8 @@ interface PlannerConversationHost {
     catalog(): TaskQueryCatalog;
     /** Whether autorun is on now (ADR-0030); the planner is told in the turn after it changes. */
     autorun(): boolean;
+    /** The enabled runners and allowlist as of now; the planner is told in the turn after either changes. */
+    assignmentScope(): AssignmentScope;
     /** Run updates no turn has carried yet, taken by the turn that asks: the next turn is told, whoever opens it. */
     takeRunUpdates(): string[];
     tasks(): readonly Task[];
@@ -975,6 +1007,8 @@ interface PlannerConversationHost {
     turnAborted(): void;
     /** A planner turn let the conversation go, so the next one may take it. */
     turnReleased?(): void;
+    /** A turn ended on the planner's usage limit, which it reported as `said`: what is sent again, and when. */
+    usageLimit(said: TurnFailure): PlannerLimit;
 }
 /**
  * A conversation edit (rewind, fork) the conversation refused because the
@@ -1003,6 +1037,26 @@ declare class ConversationBusyError extends ConversationEditError {
 declare class PlannerTurnDiscardedError extends Error {
     constructor(options?: ErrorOptions);
 }
+/**
+ * A wake-up turn's backend ended without a reply — a dead agent, a usage
+ * limit — and said why. A user's turn shows that in the chat instead; a
+ * wake-up has nobody waiting on it, so its supervisor is told (ADR-0029).
+ */
+declare class PlannerTurnFailedError extends Error {
+    constructor(message: string);
+}
+/**
+ * A planner turn ended on the planner's usage limit (#84). Nothing of it
+ * lands: the transcript keeps the failure instead, out of the planner's own
+ * dialogue, and the turn's inputs wait to be sent again — at `resendAt`, or
+ * with the next input when it is null.
+ */
+declare class PlannerUsageLimitError extends PlannerTurnFailedError {
+    readonly resendAt: Date | null;
+    /** Why nothing is sent again on its own, when nothing is. */
+    readonly held?: string;
+    constructor(limit: PlannerLimit);
+}
 /**
  * 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
@@ -1039,6 +1093,8 @@ interface TranscriptSnapshot {
     readonly researchLog: ResearchLogEntry[] | undefined;
     readonly persisted: number;
     readonly savedInBackground: number;
+    /** What the planner had been told of the user's runners when the turn began. */
+    readonly toldScope: AssignmentScope | null;
 }
 interface ReplyOptions {
     signal?: AbortSignal;
@@ -1079,6 +1135,8 @@ declare class PlannerConversation {
     private savedInBackground;
     /** What the planner was last told of autorun: by its opening prompt, or a turn's block since. */
     private toldAutorun;
+    /** The runners and allowlist the planner was last told of: its opening prompt, or a turn's block since. Null until a conversation opens. */
+    private toldScope;
     private live;
     private openTurn;
     constructor(host: PlannerConversationHost);
@@ -1250,6 +1308,19 @@ declare class PlannerConversation {
      * (ADR-0029).
      */
     private assertWakeUpAnswered;
+    /**
+     * A turn that ended on the planner's usage limit lands nothing. What it
+     * wrote is taken back, its failure is kept in its place, and the limit's
+     * wait is armed in the same save. Only a turn Ordewell started gets here,
+     * so a limit is never acted on for a planner nobody asked anything of.
+     */
+    private assertNotLimited;
+    /**
+     * A failure kept in the transcript, drawn as one on reload too, and never
+     * replayed to the planner. Stamped after the newest entry: surfaces take
+     * only entries newer than the last they synced.
+     */
+    private recordFailure;
     private assertIdle;
     /**
      * Refuse to land a turn that no longer belongs here: it was abandoned, its
@@ -1349,6 +1420,16 @@ declare class PlannerConversation {
      * conversation reaches its next turn without repeating in every one.
      */
     private autorunBlock;
+    /**
+     * The user's runner or allowlist change, when the planner was not told yet —
+     * the same once-per-change rule as autorun, for API and harness planners
+     * alike. Tasks the change leaves outside the scope are named, not touched.
+     *
+     * A reloaded session is not told: {@link resume} takes the scope as it is
+     * then, as it does the autorun rule, since the catalog the first turn carries
+     * and `list_runners` already show the runners as they are now.
+     */
+    private runnersChangedBlock;
     private runUpdatesBlock;
     /**
      * The catalog the planner may actually draw from — model ids and task-mode
@@ -2157,6 +2238,35 @@ interface Adr0013PlanIsolation {
  */
 declare function migratePlanIsolation(state: PlanIsolation | Adr0013PlanIsolation): PlanIsolation;
 
+/** The part of a run's handoff a Merge confirmation is worded from; structural, so each surface passes the handoff it holds. */
+interface MergeWordingHandoff {
+    repos: readonly {
+        path: string;
+        baseBranch?: string;
+        landed: readonly unknown[];
+    }[];
+}
+/**
+ * Whether the run spans more than a lone repo at the workspace root. A group of
+ * one at `.` is worded and drawn exactly as it was before repo groups; anything
+ * else names its repos.
+ */
+declare function isRepoGroup(handoff: {
+    repos: readonly {
+        path: string;
+    }[];
+}): boolean;
+/** The repos Merge all will merge: those with work on their integration branch, else all of them. */
+declare function reposWithWork(handoff: MergeWordingHandoff): string[];
+/**
+ * What a Merge confirmation says the branch lands on: the branch the run
+ * started on, which Merge all insists is checked out. A repo that started
+ * detached has none, and keeps the old wording.
+ */
+declare function mergeTarget(handoff: MergeWordingHandoff): string;
+/** The refusal Merge all makes when a repo is on another branch, for a confirmation to warn of; empty when no repo named a branch. */
+declare function checkoutRule(handoff: MergeWordingHandoff): string;
+
 interface ILogger {
     warn(scope: string, message: string, err?: unknown): void;
 }
@@ -2285,8 +2395,12 @@ declare class GeminiService extends BaseAiService implements IAiService {
     private genAI;
     private genAIKey;
     private model;
+    /** The id `model` was made for; the SDK's own `model.model` is its `models/…` resource path. */
+    private modelId;
     constructor(config: IConfig);
     private init;
+    /** The planner model picked for this session, as the API names it. */
+    private plannerModel;
     private getPlanningModel;
     ensureInit(): void;
     reset(): void;
@@ -2441,13 +2555,15 @@ declare class ModelResolver {
     getCachedRunnerModels(runner: string): DiscoveredModel[];
     getCachedPickerOptions(): OrchestratorOption[];
     /**
-     * The planner model's context window, from whatever catalog is already
-     * cached (#49): a vendor model comes from the picker catalog, a harness
-     * planner's model from the runner's own discovered models. Reads only —
-     * never triggers a fetch or discovery of its own, so an unknown window stays
-     * unknown and context fill is omitted rather than guessed.
+     * A model's context window from whatever catalog is already cached (#49),
+     * for a usage record whose reporter stated none: a vendor's model from the
+     * picker catalog (its own `/models` endpoint), a runner's model from that
+     * runner's own discovered listing. `source` is the record's reporter, and
+     * `model` the id it named. Reads only — never triggers a fetch or discovery
+     * of its own, so an unknown window stays unknown and context fill is
+     * omitted rather than guessed.
      */
-    contextWindowFor(modelId: string): number | undefined;
+    contextWindowFor(source: string, model: string): number | undefined;
     invalidate(): void;
 }
 
@@ -2462,9 +2578,17 @@ declare class RunnerInstallation {
     private inflight;
     private registry;
     private execImpl;
-    constructor(registry: RunnerRegistry, execImpl?: ExecImpl);
+    private now;
+    constructor(registry: RunnerRegistry, execImpl?: ExecImpl, now?: () => number);
     /** True if the runner's CLI responds to `--version`. Cached per process. */
     isInstalled(runner: string): Promise<boolean>;
+    /**
+     * Forget cached "not installed" verdicts so the next probe re-runs them. A
+     * runner-list refresh calls this, so a CLI installed while the host runs is
+     * offered without a restart. An installed verdict stays: it cannot have
+     * changed without the binary going away, and re-probing one costs a spawn.
+     */
+    refresh(): void;
     /**
      * Whether this runner can serve as a harness planner (ADR-0009, T9), and why
      * not when it cannot. Surfaces call this to grey out an unusable agent in the
@@ -2522,7 +2646,8 @@ declare function recordedInstalledPlanner(): PlannerBackendId | null;
  * 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.
+ * joins on the next probe — a runner-list refresh asks again — 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[];
@@ -2813,9 +2938,9 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     /** The model answering the planner's current message, as its `message_start` named it. */
     private plannerModel;
     /**
-     * The session's `total_cost_usd` as last reported. Undefined after a resume:
-     * the CLI restores the resumed session's running total, and what Ordewell
-     * already counted of it is not ours to know here.
+     * The session's `total_cost_usd` as last counted. A resume starts from what
+     * was counted of that session before, and is undefined without it: the CLI
+     * restores the session's running total, which holds turns counted earlier.
      */
     private reportedCostUsd;
     private reportedModelCostUsd;
@@ -2856,7 +2981,23 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     private terminalOnly;
     /** Whether this process's `runner_loaded` went out: its first `init` sends it. */
     private loadedReported;
+    /** The models `initialize` listed, which turn the ids the CLI reports back into the ones a plan holds. */
+    private listedModels;
+    /** The id the task's main thread last reported answering on. */
+    private mainModel;
+    /** What the plan should say the task runs: its spawn's model, then each switch followed. */
+    private followedModel;
+    /**
+     * Model commands sent through the chat whose switch has not been seen yet,
+     * oldest first, each with the turns still to end before its own has. Several
+     * can be pending: a command's switch is first reported by the next turn's
+     * `init`, which can be another `/model`'s.
+     */
+    private modelCommands;
     protected spawnSpec(opts: AgentStartOptions, workspace: Record<string, string>): SpawnSpec;
+    sessionCost(): RunnerSessionCost | null;
+    /** A count kept for another session says nothing of this one's. */
+    private countFrom;
     savedOutput(abs: string): boolean;
     /**
      * A task's run: the manifest decides what its mode and effort mean
@@ -2928,6 +3069,12 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     dispose(): void;
     private clearFollowOnTimer;
     protected turnPayload(message: string): string;
+    /**
+     * The CLI runs a message that starts with a slash command as that command,
+     * whether the surface sent it as one or as plain text, so the message
+     * itself says a model switch was asked for: every way into the chat counts.
+     */
+    private noteModelCommand;
     private openTurnState;
     /**
      * The echo of a steered message: the model has it. After a closed turn it
@@ -2936,6 +3083,29 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
      */
     private steerDelivered;
     protected handleLine(line: string, emit: (event: AgentEvent) => void): void;
+    /**
+     * A task's main thread reported the model it answers on. A change is the
+     * user's own switch when a model command went out before it: Ordewell never
+     * passes `--fallback-model`, so nothing else should move it. A change with
+     * no command before it is reported as drift, and the plan does not follow
+     * it. A command whose turn ended with the model unchanged switched nothing,
+     * and is let go.
+     *
+     * Effort is never reported (recorded on 2.1.302, `task-effort-command`):
+     * `init` names the model alone, its `per_turn_effort_active` says effort is
+     * on, not which; `/effort low` only prints that it set it; and `/model`
+     * takes no effort (`/model haiku high` is "not found"). So a switch carries
+     * no effort and the plan's stays as planned.
+     */
+    private followModel;
+    /** Whether the model value `asked` runs as the id `resolved`, by what `initialize` lists. */
+    private runsAs;
+    /**
+     * The value `initialize` lists for the id a model runs as. Several can share
+     * one (`sonnet`, `default`); the one asked for wins, and `default` only as a
+     * last resort, since it names whatever the CLI's default becomes.
+     */
+    private listedModel;
     /**
      * `--permission-mode auto` on a model or account without auto mode is not
      * refused: the CLI says nothing and starts in `default`, then asks about every
@@ -2975,7 +3145,8 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
      * What only the result line knows: the cost, which covers every call the
      * session made — subagents included, since none of their lines carries one —
      * and the planner model's window. `total_cost_usd` is a running total, so a
-     * turn reports its growth. The first turn after a resume only sets the
+     * turn reports its growth. After a resume it grows from what was counted of
+     * the session before; with no count kept, the first turn only sets the
      * baseline: its total includes turns counted before, and a turn's own share
      * cannot be told apart from them.
      */
@@ -3014,6 +3185,11 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
     private turn;
     /** The last turn this adapter ended — so its second end signal, landing late, ends nothing. */
     private endedTurnId;
+    /**
+     * The account's limit windows as Codex last reported them. Only read when a
+     * turn fails on the usage limit; an update on its own acts on nothing.
+     */
+    private rateLimits;
     /** An interrupt was asked for during this turn, so however it ends, it was cut short. */
     private interruptRequested;
     /**
@@ -3107,6 +3283,7 @@ declare class CodexAdapter extends StdioAgentAdapter implements TaskModeAgentAda
     /** `turn/start`'s answer. One for a turn that has since closed or been replaced names and closes nothing. */
     private turnAnswered;
     protected handleLine(line: string, emit: (event: AgentEvent) => void): void;
+    private turnFailed;
     private turnStarted;
     /**
      * Ahead of the event that ends the turn: a steer Codex accepted and the turn
@@ -3482,6 +3659,8 @@ interface SessionCatalogDeps {
     };
     /** The runners of the plan being edited; empty while the session has none. */
     planRunners: () => RunnerId[];
+    /** Whether a task's runner is up: an attempt claimed, running, quiet or waiting on someone. */
+    liveRunner?: (taskId: string) => boolean;
 }
 /**
  * What a session may assign: the enabled runners, their modes, the models
@@ -3505,6 +3684,8 @@ declare class SessionCatalog {
      * has since cleared.
      */
     allowlist(): Record<string, string[]>;
+    /** The enabled runners and allowlist together, for whoever compares an assignment with them. */
+    scope(): AssignmentScope;
     /** The models the user allows on one runner; unset means no restriction. */
     allowlistFor(runner: RunnerId): string[] | undefined;
     /**
@@ -3535,6 +3716,12 @@ declare class SessionCatalog {
      * asked for.
      */
     live(): Promise<TaskQueryCatalog>;
+    /**
+     * What {@link live} answers, from what is cached and without discovering:
+     * the enabled runners, however the plan was started. The per-turn block
+     * reads this, so it can never offer a different set than `list_runners`.
+     */
+    current(): TaskQueryCatalog;
     queryCatalog(runners: RunnerId[]): TaskQueryCatalog;
     /**
      * The catalog a model/task-mode edit is checked against — the same
@@ -3560,6 +3747,13 @@ declare class SessionCatalog {
     }>;
 }
 
+/**
+ * A model's context window from a catalog Ordewell already holds — a runner's
+ * own model listing or a provider's own models endpoint, never a table kept in
+ * Ordewell. `source` is the record's reporter: a runner id or a vendor id.
+ */
+type CatalogWindow = (source: string, model: string) => number | undefined;
+
 /** The `planner_usage` member of the session broadcast union. */
 type PlannerUsageMessage = Extract<SessionMessage, {
     type: 'planner_usage';
@@ -3574,7 +3768,11 @@ type PlannerUsageMessage = Extract<SessionMessage, {
  * defined — this module just holds the state and the broadcast shape.
  */
 declare class PlannerUsageLedger {
+    private readonly catalogWindow;
     private usage;
+    private windows;
+    /** `catalogWindow` serves the window of a planner model whose backend reports none. */
+    constructor(catalogWindow?: CatalogWindow);
     /** Fold one model call's record into the totals; returns the running ledger. */
     record(record: UsageRecord): PlannerUsage;
     /** Adopt a persisted ledger (a reopened session) or start from zero. */
@@ -3612,9 +3810,10 @@ interface SessionEventRelayDeps {
  * observers. A wait on a usage limit, and a task gone idle, reach surfaces as
  * the task's status; `onUsageLimitWait` and `onTaskIdle` themselves are for
  * the supervisor to wake on. The end-of-run handoff is marked by supervision
- * and remembered for a surface joining late, so Session announces it too.
+ * and remembered for a surface joining late, so Session announces it too. A
+ * model switch is a plan edit, which Session's editor announces as one.
  */
-type RelayObserver = Required<Omit<OrchestratorObserver, 'onTaskSettled' | 'onRunStarted' | 'onAutoMerge' | 'onUsageLimitWait' | 'onTaskIdle' | 'onIsolationHandoff'>>;
+type RelayObserver = Required<Omit<OrchestratorObserver, 'onTaskSettled' | 'onRunStarted' | 'onAutoMerge' | 'onUsageLimitWait' | 'onModelSwitched' | 'onTaskIdle' | 'onIsolationHandoff'>>;
 /**
  * Turns orchestrator and planner events into {@link SessionMessage}
  * broadcasts — the one place a surface's view of a Session is produced. It
@@ -3698,11 +3897,12 @@ interface TaskLogFile {
 /** The attempts a task has a log for, oldest first. */
 declare function listTaskLogAttempts(location: TaskLogLocation, taskId: string): number[];
 /**
- * Start the next attempt's file. Numbered from what is on disk rather than
- * from the orchestrator's count, which restarts at one whenever a plan is
- * loaded and would overwrite the attempts before it.
+ * Start an attempt's file, under the attempt's own number so its log and its
+ * usage ledger name the same attempt. Without one, or when that file already
+ * exists, it takes the next number after what is on disk: nothing saved is
+ * ever overwritten.
  */
-declare function openTaskLog(location: TaskLogLocation, taskId: string): TaskLogFile;
+declare function openTaskLog(location: TaskLogLocation, taskId: string, attempt?: number): TaskLogFile;
 /**
  * One attempt's events, in order; empty when it has no log. A line that does
  * not parse is skipped — the last one, most likely, cut off by a crash
@@ -3710,6 +3910,42 @@ declare function openTaskLog(location: TaskLogLocation, taskId: string): TaskLog
  */
 declare function readTaskLog(location: TaskLogLocation, taskId: string, attempt: number): TaskLogEvent[];
 
+interface TaskLogRecorderDeps {
+    broadcast: SessionBroadcaster;
+    /** Where the session's logs go, read as each attempt starts: a session's id can change between plans. */
+    location: () => TaskLogLocation;
+    /** Opens an attempt's file, under the attempt's number when the spawn named one; tests pass one that never touches the disk. */
+    open?: (location: TaskLogLocation, taskId: string, attempt?: number) => TaskLogFile;
+    flushMs?: number;
+    logger?: ILogger;
+}
+/**
+ * Keeps each structured task's log (ADR-0018, P1): every event of an attempt
+ * is appended to that attempt's file and broadcast as `task_log`, in the same
+ * batches, so what a surface saw live and what it reloads are one sequence.
+ *
+ * It sits around the runner rather than inside the orchestrator, which stays
+ * unaware of logs.
+ */
+declare class TaskLogRecorder {
+    private readonly deps;
+    private readonly open;
+    private readonly flushMs;
+    private readonly logger;
+    /** Each task's latest attempt, by the session it records: its log takes a {@link note} until the next attempt starts. */
+    private readonly latest;
+    constructor(deps: TaskLogRecorderDeps);
+    wrap(runner: IRunner): IRunner;
+    /**
+     * An entry the session did not emit, written into the log of the attempt
+     * that runs `sessionId` and sent at once: what Ordewell made of one of its
+     * events once that settled. Dropped once the task's next attempt started.
+     */
+    note(sessionId: string, taskId: string, entry: TaskLogEvent): void;
+    /** Start a new attempt's log for `session`, opening with the skills it was given, and keep it until the session exits. */
+    record(taskId: string, session: IRunnerSession, skills?: readonly TaskSkillSnapshot[], attemptNumber?: number): void;
+}
+
 /**
  * Options for plan generation. Progress is not overridable: every planner
  * progress event is translated to a SessionMessage inside the Session and
@@ -3794,7 +4030,7 @@ interface SessionDeps {
     /** Persistence seam. Defaults to the saved-session store under the workspace. */
     saveSession?: SaveSession;
     /** Where a structured task's log is saved (ADR-0018, P1). Defaults to a file per attempt beside the session's. */
-    openTaskLog?: (location: TaskLogLocation, taskId: string) => TaskLogFile;
+    openTaskLog?: (location: TaskLogLocation, taskId: string, attempt?: number) => TaskLogFile;
     /** The Ordewell MCP server a harness planner's tools are served from (ADR-0022). Defaults to the process's one. */
     mcpServer?: OrdewellMcpServer;
 }
@@ -3826,6 +4062,8 @@ interface SessionParts {
     usage: PlannerUsageLedger;
     approvals: PendingApprovals;
     approvalPolicy: ApprovalPolicy;
+    /** Where the Session writes what it made of a task's event into that attempt's log. */
+    taskLogs: Pick<TaskLogRecorder, 'note'>;
     fetcher: IWebFetcher;
     skillsService: Pick<SkillsService, 'findSkill' | 'listSkills' | 'searchedDirs' | 'forRoot'>;
     saveSession: SaveSession;
@@ -3873,6 +4111,7 @@ declare class Session {
     private readonly fsAdapter;
     private readonly approvals;
     private readonly approvalPolicy;
+    private readonly taskLogs;
     private readonly fetcher;
     private readonly settingsFn;
     private readonly save;
@@ -4072,6 +4311,8 @@ declare class Session {
      * boundary rewrites `in_progress` to `pending` — nothing is running when a
      * session comes off a file — so a surface that re-reads the plan mid-run must
      * come here instead, or every task it is watching reads as never started.
+     * An archived snapshot carries the task as it is now: a retry or continue
+     * keeps the archive while the live task runs on and spends more.
      */
     get currentPlanState(): PlanState | null;
     get currentGoal(): string;
@@ -4248,8 +4489,16 @@ declare class Session {
     executePlan(): Promise<void>;
     private idlePlan;
     private runWholePlan;
+    /**
+     * Execute while a run is under way (#95): the seam has approved every task,
+     * as executing does, and the run takes them in. A run the scheduler was not
+     * driving, one task started on its own, becomes the plan's run, as Execute
+     * would make it.
+     */
+    private joinRun;
     approveReview(): Promise<LegacyPlanState>;
-    forceStartTask(taskId: string): Promise<void>;
+    /** Answers the line saying the task waits for its dependencies, when it was queued behind them rather than started. */
+    forceStartTask(taskId: string): Promise<string | undefined>;
     private startOneTask;
     runTask(taskId: string): Promise<void>;
     /**
@@ -4274,8 +4523,22 @@ declare class Session {
     markTaskIncomplete(taskId: string): Promise<void>;
     /** Resume a task paused on a usage limit now, once the user says it has reset; see {@link TaskOrchestrator.resumeNow}. */
     resumeNow(taskId: string): Promise<void>;
+    /**
+     * Keep what waits on the planner's usage limit from being sent at the reset:
+     * it goes with the user's next message instead. False when nothing waits on
+     * a reset.
+     */
+    cancelPlannerResend(): boolean;
     /** Keep a task paused on a usage limit from resuming on its own; see {@link TaskOrchestrator.cancelScheduledResume}. */
     cancelScheduledResume(taskId: string): boolean;
+    /**
+     * The plan follows a model switch the user made in the runner (#106), and
+     * the task's log says what the plan holds once that settled: a write-back
+     * not made — no model command asked for the change, or the edit failed — is
+     * stated, never shown as made. Once the switch's attempt has ended, the plan
+     * may be another one, so nothing of it is said.
+     */
+    private followRunnerModel;
     /** Said through both channels: a host shows one or the other, never both (the daemon's toasts are no-ops). */
     private notice;
     approveCheckpoint(taskId: string): void;
@@ -4575,6 +4838,10 @@ interface ErrorBody {
 interface OkResponse {
     ok: boolean;
 }
+/** A task start's answer: `queued` says why it did not start now, when the task waits for its dependencies instead. */
+interface TaskStartResponse extends OkResponse {
+    queued?: string;
+}
 /**
  * A plan as the planner routes return it: the session's plan state, not the
  * `SerializedPlan` a websocket `plan_generated` carries. The two differ —
@@ -5006,6 +5273,7 @@ declare class StructuredSession extends AbstractRunnerSession {
     private messageCount;
     private interrupting;
     private lastSessionId;
+    private lastSessionCost;
     private readonly structuredEmitter;
     private permissionCount;
     /**
@@ -5080,6 +5348,7 @@ declare class StructuredSession extends AbstractRunnerSession {
     removeQueued(id: string): boolean;
     queued(): QueuedTaskMessage[];
     nativeSessionId(): string | null;
+    sessionCost(): RunnerSessionCost | null;
     answerPermission(id: string, decision: ApprovalDecision): boolean;
     /** Every open request goes unanswered once the process that asked is gone. */
     private withdrawPermissions;
@@ -5164,34 +5433,6 @@ type Continuability = {
 declare function continuability(task: Task): Continuability;
 declare function canContinue(task: Task): boolean;
 
-interface TaskLogRecorderDeps {
-    broadcast: SessionBroadcaster;
-    /** Where the session's logs go, read as each attempt starts: a session's id can change between plans. */
-    location: () => TaskLogLocation;
-    /** Opens an attempt's file; tests pass one that never touches the disk. */
-    open?: (location: TaskLogLocation, taskId: string) => TaskLogFile;
-    flushMs?: number;
-    logger?: ILogger;
-}
-/**
- * Keeps each structured task's log (ADR-0018, P1): every event of an attempt
- * is appended to that attempt's file and broadcast as `task_log`, in the same
- * batches, so what a surface saw live and what it reloads are one sequence.
- *
- * It sits around the runner rather than inside the orchestrator, which stays
- * unaware of logs.
- */
-declare class TaskLogRecorder {
-    private readonly deps;
-    private readonly open;
-    private readonly flushMs;
-    private readonly logger;
-    constructor(deps: TaskLogRecorderDeps);
-    wrap(runner: IRunner): IRunner;
-    /** Start a new attempt's log for `session`, opening with the skills it was given, and keep it until the session exits. */
-    record(taskId: string, session: IRunnerSession, skills?: readonly TaskSkillSnapshot[]): void;
-}
-
 declare function stripAnsi(text: string): string;
 
 /**
@@ -5607,4 +5848,4 @@ declare const DEFAULT_MAX_PARALLEL = 5;
  */
 declare function parseMaxParallel(value: unknown): number | null;
 
-export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, type AdoptSessionResponse, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApplyTaskOpsResult, ApprovalAnswer, type ApprovalAnswerResponse, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, ApprovalRequest, type ApprovalRequestMessage, type ApprovalsResponse, type AskOptions, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, type ByPlannerBackend, CHAT_COMMANDS, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CancelPlanningResponse, type CancelResumeResponse, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, CodexSandboxAvailability, type CommandDescriptor, CommandLineTooLongError, type CommandOutcome, type CommandsResponse, type ConfiguredPlanner, type Consent, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompactResponse, type ConversationCompaction, ConversationEditError, type ConversationFork, type ConversationForkResponse, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationRewindResponse, type ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, DEFAULT_WEB_READ_BUDGET, type DaemonErrorCode, type DecideOptions, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ErrorBody, type ExecImpl, ExecutableNotFoundError, type ExecuteResponse, ExecutionActor, type ExecutionCommand, ExecutionCommandName, ExecutionCommands, type ExecutionHost, ExecutionRecord, FindSymbolOptions, type ForceSendResponse, GREP_PCRE_PROBE_ARGS, GeminiService, type GeneratePlanResponse, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, GuardTarget, GuardTrip, HARNESS_PLANNER_REASON, HEADLESS_CLI_COMMANDS, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, type IsolationDiffResponse, IsolationLandedTask, type IsolationMergeResponse, IsolationMergeResult, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, type LiveOutputLookup, LiveTail, LiveTailOptions, type LoopGuard, type MappedTool, type MergeGateEntry, type MergeGateResponse, ModelResolver, type ModelResolverDeps, type ModelsResponse, NoPlanError, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, type OkResponse, OpenAiService, OpenCodeAdapter, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, type PlanRequest, type PlanResponse, PlanState, PlanStatus, PlanStore, Planner, type PlannerBackendEntry, PlannerBackendId, type PlannerChoice, type PlannerCommandSyntax, type PlannerModelCandidate, type PlannerModelChoice, type PlannerModelLookup, PlannerModelMemory, type PlannerModelRecall, type PlannerModelSource, type PlannerModelStore, type PlannerNotReady, PlannerNotReadyError, type PlannerReadinessConfig, type PlannerSelectionChange, type PlannerSelectionCurrent, type PlannerSelectionResult, type PlannerSelectionState, type PlannerSubmission, PlannerToolHandler, PlannerTurnDiscardedError, PlannerTurnStoppedError, type PlannerUsability, PlannerUsage, type PrdBlock, type PrdResponse, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, type RemoveMessageResponse, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolveConflictResponse, type ResolvedChoice, type ResolvedPlanner, type RewindTarget, type RewindTargetsResponse, RunMergeView, type RunSnapshotFrame, RunView, RunnerApprovals, RunnerCommand, RunnerId, RunnerInstallation, RunnerManifest, RunnerModeInfo, RunnerRegistry, type RunnerSpawnOptions, type RunnersResponse, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SUPERVISOR_LEVELS, SYMBOL_LANGUAGES, type SaveSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionFrame, type SessionListResponse, SessionMessage, type SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionResponse, type SessionRuntimeSettings, type SettingsResponse, type SettingsUpdateResponse, SkillInfo, type SkillInvocation, SkillLoad, SkillsService, type SpawnSpec, StartAdmission, StdioAgentAdapter, type StopResponse, type StreamStamp, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, SupervisorLevel, type SupervisorPolicy, SurfacePlan, SurfacePlanState, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TERMINAL_UI_COMMANDS, Task, TaskCompleteArgs, type TaskLogAttemptsResponse, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, type TaskLogResponse, TaskMessageFrom, type TaskMessageResponse, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WebRead, type WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorkspacesResponse, type WorktreeIsolationDeps, abbreviateHome, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexSandboxNotice, configuredProviders, continuability, createAiService, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultEnabledRunners, defaultLogger, definitionPattern, deleteSession, describeMergeResult, describePlannerNotReady, detectInstalledPlanner, discoverGeminiModels, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, findInstalledPlanner, formatSearchOutput, getLatestSession, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, installedPlannerAnswered, installedPlannerDetected, isApiProvider, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlannerBackend, isVendorModelFor, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseSearchHits, parseTaskQueryJson, planDirectLaunch, plannerBackendEntries, plannerMessage, plannerNotReady, plannerNotReadyFor, plannerTranscript, prefixModelId, providerForRunner, readDaemonToken, readTaskLog, recordInstalledPlanner, recordedInstalledPlanner, referencePattern, removedPluginNotice, renderTaskQueryAnswer, resetInstalledPlanner, resolveProviderFromPrefix, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, selectPlanner, sessionDataDir, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, taskQuerySignature, textHasTaskQuery, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writePrivateFile };
+export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, type 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, AssignmentScope, 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, type MergeWordingHandoff, 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, PlannerUsageLimitError, 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, RunnerSessionCost, 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, type TaskStartResponse, 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, checkoutRule, 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, isRepoGroup, isVendorModelFor, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, mapAgentTool, mergeTarget, 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, reposWithWork, 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 };