@ordewell/core 0.5.3 → 0.5.5

package/dist/index.d.mts

@@ -1,17 +1,17 @@
-import { F as RunnerId, u as PlanStatus, L as LegacyPlanState, k as IsolationMergeResult, g as IsolationLandedTask, I as IWorktreeIsolation, w as RepoGroupLayout, a as DiscoveredModel, T as Task, y as ResearchProgress, x as ResearchLogEntry, C as ConversationMessage, V as TaskSnapshot, d as IsolationHandoff, J as TaskIsolation, r as IsolationView, P as PlanIsolation, Q as QueuedMessage, A as ActiveTaskSession, E as ResearchToolType, t as PlanState, a3 as Verdict } from './Task-BxQkPlXO.mjs';
-export { D as DiscoveredMode, b as IntegrationDisposal, c as IsolationAvailability, e as IsolationHandoffRepo, f as IsolationInactiveReason, h as IsolationLanding, i as IsolationMergeBlock, j as IsolationMergeBlockReason, l as IsolationOutcome, m as IsolationRepo, n as IsolationRun, o as IsolationTaskRecord, p as IsolationTaskRepo, q as IsolationTaskStatus, M as Message, s as PlanModificationWarnings, v as PreparedTask, R as RepairEvidence, z as ResearchStep, B as ResearchStepOutcome, S as StreamEvent, G as StreamStepEvent, H as StreamThinkingEvent, K as TaskIsolationState, N as TaskMode, O as TaskModelAssignment, U as TaskOutputSummary, W as TaskStatus, X as TaskType, Y as TaskWithParent, Z as ThinkingBlock, _ as UserPromptEntry, $ as UserStep, a0 as ValidationCheck, a1 as ValidationContext, a2 as ValidationResult, a4 as VerificationCheck, a5 as addTaskToPlan, a6 as createEmptyPlan, a7 as createTask, a8 as emptyWarnings, a9 as flattenTasks, aa as flattenTasksWithParents, ab as migrateLegacyPlan, ac as migratePlanState, ad as migrateTask, ae as removeTaskFromPlan, af as renumberTasks, ag as updateTaskInPlan, ah as validateModifiedPlan, ai as warningsText } from './Task-BxQkPlXO.mjs';
-import { f as IFileSystem, R as ReadFileOpts, T as ToolOutcome, d as GrepOptions, c as GlobOptions, b as FindSymbolOptions, I as IConfig, A as AiProvider, r as ProviderModelLists, i as ITerminalSession, h as ITerminalRunner, w as RunnerRegistry, k as OrchestratorOption, u as RunnerInvocation, g as IPluginStore, v as RunnerPluginManifest, t as ResolveContext } from './ITerminalRunner-ByeoLF57.mjs';
-export { a as AllProviderModels, B as BlockingPrompt, C as CatalogModel, D as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, e as GrepOutputMode, M as ModelCatalog, j as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginCloneFn, l as PluginEntry, m as PluginFeatures, n as PluginMode, o as PluginModelDiscovery, p as PluginRunnerDef, q as ProviderCredentialSource, s as ProviderModelsResult, S as SEARCH_EXCLUSIONS, x as collectProviderCredentials, y as enabledRunners, z as fetchAllProviderModels, E as isReservedRunnerName, H as knownModelId, J as resolveModelShortcut, K as resolveProvider, L as toOrchestratorOptions } from './ITerminalRunner-ByeoLF57.mjs';
+import { H as RunnerId, v as PlanStatus, L as LegacyPlanState, k as IsolationMergeResult, g as IsolationLandedTask, I as IWorktreeIsolation, y as RepoGroupLayout, a as DiscoveredModel, T as Task, a3 as UsageRecord, O as SubagentOutcome, B as ResearchProgress, z as ResearchLogEntry, C as ConversationMessage, Z as TaskSnapshot, d as IsolationHandoff, U as TaskIsolation, s as IsolationView, P as PlanIsolation, Q as QueuedMessage, A as ActiveTaskSession, G as ResearchToolType, u as PlanState, aa as Verdict } from './Task-Vl5Zq_D-.mjs';
+export { D as DiscoveredMode, b as IntegrationDisposal, c as IsolationAvailability, e as IsolationHandoffRepo, f as IsolationInactiveReason, h as IsolationLanding, i as IsolationMergeBlock, j as IsolationMergeBlockReason, l as IsolationOutcome, m as IsolationPruneResult, n as IsolationRepo, o as IsolationRun, p as IsolationTaskRecord, q as IsolationTaskRepo, r as IsolationTaskStatus, M as Message, t as PlanModificationWarnings, w as PlannerUsage, x as PreparedTask, R as RepairEvidence, E as ResearchStep, F as ResearchStepOutcome, S as StreamEvent, J as StreamStepEvent, K as StreamThinkingEvent, N as SubagentLogEntry, V as TaskIsolationState, W as TaskMode, X as TaskModelAssignment, Y as TaskOutputSummary, _ as TaskStatus, $ as TaskType, a0 as TaskWithParent, a1 as ThinkingBlock, a2 as UsageLine, a4 as UsageTotals, a5 as UserPromptEntry, a6 as UserStep, a7 as ValidationCheck, a8 as ValidationContext, a9 as ValidationResult, ab as VerificationCheck, ac as addPlannerUsage, ad as addTaskToPlan, ae as addUsage, af as createEmptyPlan, ag as createTask, ah as emptyWarnings, ai as flattenTasks, aj as flattenTasksWithParents, ak as isMeasured, al as keepExecutionState, am as migrateLegacyPlan, an as migratePlanState, ao as migrateTask, ap as partedPromptUsage, aq as plannerContextFill, ar as removeTaskFromPlan, as as renumberTasks, at as updateTaskInPlan, au as usageLine, av as validateModifiedPlan, aw as warningsText } from './Task-Vl5Zq_D-.mjs';
+import { f as IFileSystem, R as ReadFileOpts, T as ToolOutcome, d as GrepOptions, c as GlobOptions, b as FindSymbolOptions, I as IConfig, A as AiProvider, r as ProviderModelLists, i as ITerminalSession, h as ITerminalRunner, w as RunnerRegistry, k as OrchestratorOption, u as RunnerInvocation, g as IPluginStore, v as RunnerPluginManifest, t as ResolveContext } from './ITerminalRunner-C77ZNZS9.mjs';
+export { a as AllProviderModels, B as BlockingPrompt, C as CatalogModel, D as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, e as GrepOutputMode, M as ModelCatalog, j as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginCloneFn, l as PluginEntry, m as PluginFeatures, n as PluginMode, o as PluginModelDiscovery, p as PluginRunnerDef, q as ProviderCredentialSource, s as ProviderModelsResult, S as SEARCH_EXCLUSIONS, x as collectProviderCredentials, y as enabledRunners, z as fetchAllProviderModels, E as isReservedRunnerName, H as knownModelId, J as resolveModelShortcut, K as resolveProvider, L as toOrchestratorOptions } from './ITerminalRunner-C77ZNZS9.mjs';
 import { I as IApproval, d as ApprovalRequest, a as ApprovalMode } from './ApprovalPolicy-BVhGdECT.mjs';
 export { A as ApprovalKind, b as ApprovalPolicy, c as ApprovalPolicyOptions, e as ApprovalSource, D as DENY_ALL } from './ApprovalPolicy-BVhGdECT.mjs';
-import { T as TaskOp, f as SessionBroadcaster, h as SessionNotice } from './plan-utils-CtB3_Ovf.mjs';
-export { A as Adr0013IsolationRun, a as Adr0013PlanIsolation, b as Adr0013TaskRecord, c as ApplyTaskOpsResult, C as CHECKPOINT_TRUNCATE_LENGTH, S as SerializedPlan, d as SerializedTask, e as SerializedTaskStatus, g as SessionMessage, i as TaskRef, j as applyTaskOps, k as canMergeTasks, l as canSetDependencies, m as canSplitTask, n as capConflictFiles, o as classifyOutcome, p as dependencyCandidates, q as dependentsOf, r as executionSummary, s as migratePlanIsolation, t as parseTaskOpsJson, u as serializePlan, v as serializeTask, w as serializeTaskStatus, x as summarizeToolCall, y as textHasTaskOps, z as truncateCheckpointSummary } from './plan-utils-CtB3_Ovf.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-DVJ7HV3k.mjs';
-export { M as ManifestLookup, b as buildModeGuide, f as filteredBuildModes, r as resolveDefaultMode, a as resolveTaskMode, c as runnerModesFrom } from './ModeResolver-DVJ7HV3k.mjs';
+import { t as TaskOp, n as SessionBroadcaster, p as SessionNotice } from './plan-utils-pE4TBwxl.mjs';
+export { A as Adr0013IsolationRun, a as Adr0013PlanIsolation, b as Adr0013TaskRecord, c as ApplyTaskOpsResult, d as ApprovalBlock, e as ApprovalStatus, C as CHECKPOINT_TRUNCATE_LENGTH, f as ConversationInput, g as ConversationView, D as DisplayBlock, E as EMPTY_CONVERSATION, h as EMPTY_HOLD, G as GatedConversation, L as LocalEntry, M as MessageBlock, i as MessageRole, N as NO_TURN, O as OutputPreview, P as PlanBlock, j as PlanMarkerStatus, k as PromptHold, S as SerializedPlan, l as SerializedTask, m as SerializedTaskStatus, o as SessionMessage, q as SubagentBlock, r as SubagentChild, s as SubagentStatus, T as TakenPrompt, u as TaskRef, v as ThinkingDisplayBlock, w as ToolBlock, x as ToolHeadline, y as ToolStatus, z as TurnGate, U as UsageBlock, B as aheadOfDraft, F as applyTaskOps, H as canMergeTasks, I as canSetDependencies, J as canSplitTask, K as capConflictFiles, Q as classifyOutcome, R as dependencyCandidates, V as dependentsOf, W as drainNext, X as executionSummary, Y as followTurn, Z as fromTranscript, _ as hasHiddenDetail, $ as holdPrompt, a0 as migratePlanIsolation, a1 as outputLines, a2 as outputPreview, a3 as parseTaskOpsJson, a4 as reduceConversation, a5 as serializePlan, a6 as serializeTask, a7 as serializeTaskStatus, a8 as stopTurn, a9 as summarizeToolCall, aa as taskStartedNotice, ab as textHasTaskOps, ac as toolHeadline, ad as truncateCheckpointSummary, ae as unsendAll, af as unsendLatest } from './plan-utils-pE4TBwxl.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-D-SUFRNF.mjs';
+export { M as ManifestLookup, b as buildModeGuide, f as filteredBuildModes, r as resolveDefaultMode, a as resolveTaskMode, c as runnerModesFrom } from './ModeResolver-D-SUFRNF.mjs';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
-import { b as PlanParseError } from './parsing-DRp4dPC0.mjs';
-export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, T as TASK_OPS_ENVELOPE_KEY, c as TASK_QUERY_ENVELOPE_KEY, d as checkDepsResolve, e as checkImmutableLog, f as checkInProgress, g as checkNoCycles, h as checkUniqueIds, i as escapeControlCharsInStrings, j as extractJsonObject, k as extractObjectWithBalance, l as extractObjectsWithKey, m as looksLikePlanAttempt, p as parsePartialPlan, n as parsePlanJson, s as stripModelNoise, o as stripTrailingCommas, v as validatePlanModification } from './parsing-DRp4dPC0.mjs';
+import { b as PlanParseError } from './parsing-CDtRSxBY.mjs';
+export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, T as TASK_OPS_ENVELOPE_KEY, c as TASK_QUERY_ENVELOPE_KEY, d as checkDepsResolve, e as checkImmutableLog, f as checkInProgress, g as checkNoCycles, h as checkUniqueIds, i as escapeControlCharsInStrings, j as extractJsonObject, k as extractObjectWithBalance, l as extractObjectsWithKey, m as looksLikePlanAttempt, o as opensWithJsonObject, p as parsePartialPlan, n as parsePlanJson, s as stripModelNoise, q as stripTrailingCommas, v as validatePlanModification } from './parsing-CDtRSxBY.mjs';
 export { resolveOrderLabel, taskOrderLabel } from './order-labels.mjs';
 
 interface SessionMeta {
@@ -1129,26 +1129,69 @@ declare class HeadlessRunner extends AbstractRunner<HeadlessSession> {
  * turn that emits nothing but `assistant_text` and `turn_end`.
  */
 type AgentEvent = 
-/** A chunk of the assistant's reply. Concatenated in order to form the turn's text. */
+/**
+ * A complete run of the assistant's reply. Concatenated in order to form the
+ * turn's text. When the same run already streamed as `assistant_text_delta`,
+ * this is the authoritative copy of it — it replaces the deltas, it is not
+ * appended after them.
+ */
 {
     type: 'assistant_text';
     text: string;
 }
-/** Reasoning the agent chose to expose. Never contributes to the reply text. */
+/**
+ * An incremental piece of the assistant's reply, for agents that stream
+ * partial messages. The planner's own text only: a subagent's words never
+ * arrive here, so they can never become the reply.
+ */
+ | {
+    type: 'assistant_text_delta';
+    text: string;
+}
+/**
+ * Reasoning the agent chose to expose. Never contributes to the reply text.
+ * Like `assistant_text`, it supersedes deltas already streamed for it.
+ */
  | {
     type: 'thinking';
     text: string;
+    subagentId?: string;
 } | {
+    type: 'thinking_delta';
+    text: string;
+    subagentId?: string;
+}
+/** `subagentId` marks a call made inside a subagent rather than by the planner itself. */
+ | {
     type: 'tool_call';
     id: string;
     name: string;
     args: Record<string, unknown>;
+    subagentId?: string;
 } | {
     type: 'tool_result';
     id: string;
     name: string;
     output: string;
     success: boolean;
+    subagentId?: string;
+}
+/** One model call's usage, as the agent reported it — never estimated. */
+ | {
+    type: 'usage';
+    record: UsageRecord;
+}
+/** The agent delegated `brief` to a subagent, whose events carry `subagentId` until it finishes. */
+ | {
+    type: 'subagent_started';
+    subagentId: string;
+    brief: string;
+    model?: string;
+} | {
+    type: 'subagent_finished';
+    subagentId: string;
+    outcome: SubagentOutcome;
+    digest: string;
 }
 /**
  * The agent asked to do something its read-only mode does not cover. Always
@@ -1269,8 +1312,8 @@ interface CliAgentAiServiceDeps extends Partial<AgentProcessDeps> {
  * `GeminiService`. It deliberately does **not** extend {@link BaseAiService}:
  * that class's body is Ordewell executing research tools on a model's behalf,
  * which is precisely the part a coding agent replaces. What it reuses instead
- * is everything above the transport — `classifyPlannerReply`, the bounded
- * corrective re-emit loop, `parsePlanJson`, the `ResearchProgress` events the
+ * is everything above the transport — `settleReply` (reply classification
+ * and the bounded corrective retries), `parsePlanJson`, the `ResearchProgress` events the
  * four surfaces already render. That is why this backend reaches VS Code, the
  * web UI, the CLI and the TUI without any of them learning a coding agent is
  * on the other end.
@@ -1290,6 +1333,12 @@ declare class CliAgentAiService implements IAiService {
     private lastNativeSessionId;
     private conversation;
     private activeAbort;
+    /**
+     * Every subagent this conversation has reported starting, and finishing.
+     * Agents restate a subagent's state as it changes, and one can finish a turn
+     * or a process restart after it started; surfaces get each once, in order.
+     */
+    private readonly subagents;
     constructor(config: IConfig, deps?: CliAgentAiServiceDeps);
     hasActiveConversation(): boolean;
     /**
@@ -1308,10 +1357,10 @@ declare class CliAgentAiService implements IAiService {
     continueConversation(userMessage: string, onProgress: (progress: ResearchProgress) => void, signal?: AbortSignal): Promise<ConversationTurn>;
     private openingMessage;
     /**
-     * Drive one user message to a settled planner turn. Same shape as the API
-     * backend's conversation loop minus the tool rounds — those belong to the
-     * agent now — and with the same two policies layered on top: the
-     * empty-reply nudge, and a bounded corrective re-emit for botched JSON.
+     * Drive one user message to a settled planner turn through
+     * {@link settleReply}, the loop the API backend settles through too. The
+     * tool rounds belong to the agent now, so one call is one agent turn —
+     * continued while it left subagents running in the background.
      */
     private runConversation;
     /**
@@ -1330,12 +1379,13 @@ declare class CliAgentAiService implements IAiService {
      * degradation `restoreChat` already performs on every surface.
      */
     private ensureAdapter;
-    private startAbortScope;
     private plannerModel;
     /**
      * A single agent session that answers one prompt and exits. Used by every
      * non-conversational entry point; the plan is parsed from the reply text by
-     * the same extractor the conversational path uses.
+     * the same extractor the conversational path uses. Its envelope streams to
+     * the plan display, as a vendor planner's one-shot does, and the prose
+     * around it is not streamed at all, since no turn is open to show it in.
      */
     private oneShot;
     researchAndPlan(userDescription: string, runners: RunnerId[], modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, fs: IFileSystem, onProgress: (progress: ResearchProgress) => void, _fetcher?: IWebFetcher, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, signal?: AbortSignal): Promise<{
@@ -1365,6 +1415,12 @@ interface ConversationRequest {
     runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     autonomousDefault?: boolean;
     verificationEnabled?: 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;
     signal?: AbortSignal;
@@ -1533,7 +1589,7 @@ declare abstract class BaseAiService {
     abstract ensureInit(): void;
     hasActiveConversation(): boolean;
     pruneContext(): number;
-    protected startAbortScope(callerSignal?: AbortSignal): AbortSignal | undefined;
+    protected startAbortScope(callerSignal?: AbortSignal): AbortSignal;
     protected stopAbortScope(): void;
     sendPlanningPrompt(prompt: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Promise<Task[]>;
     continueConversation(userMessage: string, onProgress: (progress: ResearchProgress) => void, signal?: AbortSignal): Promise<ConversationTurn>;
@@ -1542,9 +1598,10 @@ declare abstract class BaseAiService {
      * Build a fresh chat for one research subagent (own history, subagent system
      * prompt, cheap model). Null means the provider does not support subagents —
      * the spawn tool then degrades to a steering message. `onReasoning` streams
-     * live reasoning deltas on models that expose them, same as the top-level loop.
+     * live reasoning deltas on models that expose them, same as the top-level loop;
+     * `onUsage` takes each call's usage, as the planner's own chat reports it.
      */
-    protected createSubagentChat(_onReasoning?: (delta: string) => void): ResearchChat | null;
+    protected createSubagentChat(_onReasoning?: (delta: string) => void, _onUsage?: (record: UsageRecord) => void): ResearchChat | null;
     /**
      * One spawn_research_agent tool call, executed at the service layer (not in
      * executeTool — that would cycle the imports). Every failure path returns a
@@ -1567,13 +1624,15 @@ declare abstract class BaseAiService {
     private static appendBudgetCountdown;
     /**
      * Run one planner conversation turn (ADR-0002): send the message, satisfy
-     * tool calls until the model answers in prose or JSON, then classify the
-     * result. The model decides transitions — there are no sentinels, no
-     * question tags, and no correction nags. A turn whose final text parses as
-     * a `{tasks:[...]}` object commits the plan; anything else is a message to
-     * the user.
+     * tool calls until the model answers in prose or JSON, and settle the reply
+     * through {@link settleReply}, which owns classification and every
+     * corrective retry. The model decides transitions — there are no sentinels
+     * and no question tags. A turn whose final text parses as a `{tasks:[...]}`
+     * object commits the plan; anything else is a message to the user.
      */
     protected runConversationTurn(ctx: ConversationTurnContext, message: string, onProgress: (progress: ResearchProgress) => void, signal?: AbortSignal): Promise<ConversationTurn>;
+    /** One model call of a conversation turn: the message, then tool rounds until the model replies without tools. */
+    private runToolRounds;
     /**
      * Run the LLM tool-calling research loop for one-shot planning. Returns
      * parsed tasks if a plan was emitted mid-loop, or null if the loop
@@ -1628,7 +1687,7 @@ declare class OpenAiService extends BaseAiService implements IAiService {
     reset(): void;
     protected streamPlanText(prompt: string, repairHint: string | undefined, onToken: (token: string) => void, onReasoning?: (token: string) => void, signal?: AbortSignal): Promise<string>;
     /** A research subagent: fresh history, digest contract, cheap model, read-only tools. */
-    protected createSubagentChat(onReasoning?: (delta: string) => void): ResearchChat | null;
+    protected createSubagentChat(onReasoning?: (delta: string) => void, onUsage?: (record: UsageRecord) => void): ResearchChat | null;
     startConversation(req: ConversationRequest): Promise<ConversationTurn>;
     researchAndPlan(userDescription: string, runners: RunnerId[], modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, fs: IFileSystem, onProgress: (progress: ResearchProgress) => void, fetcher?: IWebFetcher, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, signal?: AbortSignal): Promise<{
         tasks: Task[];
@@ -1805,7 +1864,7 @@ interface OrchestratorObserver {
      * daemon may leave unwired, so a surface without toasts can still show it.
      */
     onIsolationNotice?(data: {
-        level: 'info' | 'warn';
+        level: 'info' | 'warn' | 'error';
         message: string;
     }): void;
 }
@@ -1841,6 +1900,7 @@ declare class TaskOrchestrator {
     private running;
     private planStatus;
     private messageQueue;
+    private queueSeq;
     private reviewApproved;
     private retryCounts;
     private spawnCounts;
@@ -1976,6 +2036,8 @@ declare class TaskOrchestrator {
     get isolationRecord(): PlanIsolation | null;
     queueMessage(text: string): void;
     getQueuedMessages(): QueuedMessage[];
+    /** Take one unsent message back out of the queue; false when it was never there (or already drained). */
+    removeQueuedMessage(id: string): boolean;
     setQueuedMessages(messages: QueuedMessage[]): void;
     clearQueuedMessages(): void;
     processNextQueuedMessage(): QueuedMessage | null;
@@ -1997,6 +2059,8 @@ declare class TaskOrchestrator {
     stop(): void;
     onUserTaskComplete(taskId: string): Promise<void>;
     private onVerdict;
+    /** Whether a stopped runner's own tail says its account, not the task, ran out. */
+    private stoppedOnUsageLimit;
     private afterVerdict;
     /**
      * A repair's verdict decides only whether its work may try to land. It never
@@ -2059,11 +2123,17 @@ declare class TaskOrchestrator {
      * Cancel a running (or scheduled) task: kill its session and return it to
      * 'pending' — "not executed". The task is put on hold so the scheduler
      * doesn't immediately restart it; Retry / Force Start release the hold.
+     *
+     * The attempt's worktree is kept, as a stopped or failed one is: a runner is
+     * often cancelled because it looked stuck after doing the work, and Mark
+     * complete can still land that work. The next attempt replaces it.
      */
     cancelTask(taskId: string): Promise<void>;
+    private cancelAttempt;
     /**
      * Let go of a task that is leaving the plan. A live runner is cancelled
-     * through {@link cancelTask}; a spawn still in flight just loses its attempt,
+     * as {@link cancelTask} does, but its worktree goes: no task is left to land
+     * it into. A spawn still in flight just loses its attempt,
      * which is what makes {@link startTask} kill the session it is about to
      * receive. The id's cross-attempt bookkeeping goes too — a hold or retry
      * count kept for a task that no longer exists would be inherited by nothing.
@@ -2091,9 +2161,9 @@ declare class TaskOrchestrator {
     forceStartTask(taskId: string): Promise<void>;
     /**
      * Run exactly one task outside full-plan scheduling. The active/starting
-     * session still contributes to isRunning so every surface exposes Stop and
-     * disables Execute Plan, but onVerdict cannot auto-schedule other tasks
-     * because the plan scheduler's `running` flag remains false.
+     * session still contributes to {@link hasLiveWork} so every surface exposes
+     * Stop and disables Execute Plan, but onVerdict cannot auto-schedule other
+     * tasks because the plan scheduler's `running` flag remains false.
      */
     runTask(taskId: string): Promise<void>;
     getCompletedCount(): number;
@@ -2146,16 +2216,18 @@ declare class TaskOrchestrator {
     /** What earlier runs left merged in the group goes; a failure here is worth a word, never a stopped run. */
     private sweep;
     /**
-     * The plan's run carries on while anything has landed on its integration
-     * branch: a resumed plan's dependents must start from a tip that holds their
-     * predecessors' work, and a fresh branch from the checked-out commit does not.
+     * The plan's run carries on while it still has any record: anything landed
+     * means a resumed plan's dependents must start from a tip that holds their
+     * predecessors' work, and anything held — a kept attempt, a conflict, a
+     * repair — is work the user may still want, which a fresh run's mint would
+     * delete. Only a run with no records at all is superseded.
      */
     private continuableRun;
     /**
-     * A run with nothing landed holds only superseded attempts, so it goes whole.
-     * One that cannot be continued for another reason — it ran from a different
-     * workspace path — keeps its integration branch in each repo that has not
-     * merged it: only the user gives landed work up.
+     * A run with no records at all holds only superseded attempts, so it goes
+     * whole. One that cannot be continued for another reason — it ran from a
+     * different workspace path — keeps its integration branch in each repo that
+     * has not merged it: only the user gives landed work up.
      */
     private mintRun;
     /** Close the open run. An isolated one hands its integration branch over for review. */
@@ -2312,6 +2384,14 @@ 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.
+     */
+    contextWindowFor(modelId: string): number | undefined;
     invalidate(): void;
 }
 
@@ -2579,9 +2659,55 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter {
     readonly agentId = "claude-code";
     /** Whether this turn has already emitted reply text — see {@link handleLine}. */
     private turnHasText;
+    /** The text block streaming now follows earlier reply text, so its first delta opens the paragraph. */
+    private pendingBreak;
+    /** The model answering the planner's current message, as its `message_start` named it. */
+    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.
+     */
+    private reportedCostUsd;
+    /**
+     * Subagents started and not yet finished, keyed by the `Agent` call's id.
+     * Kept across turns: a backgrounded one reports after its turn has ended.
+     */
+    private readonly openSubagents;
+    /** Subagent messages already counted. A message arrives as one line per content block, each repeating its usage. */
+    private readonly countedSubagentMessages;
     protected spawnSpec(opts: AgentStartOptions): SpawnSpec;
     protected turnPayload(message: string): string;
     protected handleLine(line: string, emit: (event: AgentEvent) => void): void;
+    private startSubagent;
+    /**
+     * A subagent's messages do not stream, so each line's usage is the snapshot
+     * taken before generation: the prompt is real, the output a placeholder.
+     * Only the prompt side is reported — an absent output count reads as "not
+     * reported", a placeholder would read as a measurement.
+     */
+    private handleSubagentMessage;
+    /**
+     * The `Agent` call returned, so the subagent is done. Its last call — the
+     * report — never appears as a line of its own; the result carries its
+     * complete usage instead.
+     */
+    private finishForegroundSubagent;
+    /**
+     * Partial output of the planner's own message. The complete `assistant` line
+     * for each block follows its deltas and is authoritative for that block (see
+     * {@link AgentEvent}), so nothing here has to reconcile with it.
+     */
+    private handleStreamEvent;
+    /**
+     * 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
+     * baseline: its total includes turns counted before, and a turn's own share
+     * cannot be told apart from them.
+     */
+    private reportSessionCost;
 }
 
 /**
@@ -2601,6 +2727,8 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter {
 declare class CodexAdapter extends StdioAgentAdapter {
     readonly agentId = "codex";
     private threadId;
+    /** The model Codex opened the thread with — usage records name it. */
+    private threadModel;
     private nextRequestId;
     private settleHandshake;
     private handshakeError;
@@ -2610,6 +2738,12 @@ declare class CodexAdapter extends StdioAgentAdapter {
     private resumeAttempted;
     private resumeFallbackSent;
     private sandbox;
+    /**
+     * Subagent threads this session has spawned, keyed by the child thread id.
+     * Codex runs a subagent in its own thread and replays both threads' events on
+     * one stream; the thread id is what tells them apart (see {@link subagentOf}).
+     */
+    private readonly subagents;
     protected spawnSpec(opts: AgentStartOptions): SpawnSpec;
     /**
      * `initialize`, then `thread/start`, both before the first user message. The
@@ -2628,6 +2762,26 @@ declare class CodexAdapter extends StdioAgentAdapter {
     private startThread;
     protected turnPayload(message: string): string;
     protected handleLine(line: string, emit: (event: AgentEvent) => void): void;
+    /**
+     * The child thread id when `threadId` names a subagent's thread, or undefined
+     * for the planner's own. Codex replays both threads on one stream and only
+     * the thread id separates them; the first time a thread is seen it is
+     * registered so its usage and steps can be tagged with it as a subagent id.
+     */
+    private subagentOf;
+    /**
+     * One usage record per model call, from `thread/tokenUsage/updated`.
+     *
+     * The notification carries two breakdowns: `total` is cumulative for the
+     * thread and `last` is the model call that just finished (verified against
+     * the installed binary — a two-call turn ends with `last` equal to the second
+     * call and `total` equal to both summed). Emitting `total` on each update
+     * would count every earlier call again, so `last` is the record. Mapping
+     * `last.outputTokens` already includes `reasoningOutputTokens` — the thread
+     * total is `inputTokens + outputTokens`, not a sum of three — so reasoning is
+     * not added a second time. Codex reports no price.
+     */
+    private emitUsage;
     /**
      * Refuse one server→client request. Requests whose result schema can express
      * a refusal get that payload; everything else — a permission grant, a
@@ -2639,6 +2793,17 @@ declare class CodexAdapter extends StdioAgentAdapter {
     /** A tool item entering `inProgress` — announce the call so the timeline moves. */
     private emitItemStart;
     private emitItemDone;
+    /**
+     * A `collabAgentToolCall` — the planner spawning, waiting on or messaging a
+     * subagent. The call itself is planner-level tool activity; the lifecycle it
+     * carries becomes `subagent_started` / `subagent_finished`, restated as
+     * often as Codex restates it — the service reports each once. Codex tags
+     * every collab item with the parent thread, so this one never runs for a
+     * subagent.
+     */
+    private emitCollabItem;
+    /** The readable result of a collab call: the brief it sent, or what came back. */
+    private collabSummary;
 }
 
 /**
@@ -2650,10 +2815,12 @@ declare class CodexAdapter extends StdioAgentAdapter {
  * talks to it through the injected `fetch`. Both are part of the one seam the
  * tests drive.
  *
- * The turn ends when the message POST resolves. Live events stream from the
- * server's `/event` channel, but the POST is what settles the turn: an event
- * name that changes between OpenCode versions then costs liveness, not
- * correctness.
+ * The turn ends when the message POST resolves, and its response is the
+ * authoritative copy of the reply's last message. Everything else — reply text
+ * as it streams, earlier model calls' text and reasoning, per-call usage, the
+ * subagents a `task` call runs — arrives only on the server's `/event` channel.
+ * An event name that changes between OpenCode versions therefore costs that
+ * detail, never the final reply.
  */
 declare class OpenCodeAdapter implements AgentAdapter {
     private deps;
@@ -2675,9 +2842,14 @@ declare class OpenCodeAdapter implements AgentAdapter {
     /**
      * Turn one settled assistant message into events. The settled response is
      * authoritative: it names the assistant message, so its parts are the ones
-     * that make up the reply. Tool parts already seen live are deduplicated by
-     * call id; anything the stream missed (including a stream that never
-     * connected) arrives here.
+     * that make up the reply. Parts already completed live are deduplicated;
+     * anything the stream missed (including a stream that never connected)
+     * arrives here.
+     *
+     * It is only the turn's *last* message, though. OpenCode writes one
+     * assistant message per model call, so the calls before the final one —
+     * their text, reasoning and usage — reach Ordewell over the stream or not at
+     * all.
      */
     private settle;
     /**
@@ -2694,11 +2866,39 @@ declare class OpenCodeAdapter implements AgentAdapter {
     private recoverReply;
     private newestAssistantId;
     /**
-     * Emit one message part, once. OpenCode reports a tool part repeatedly as it
-     * moves through pending → running → completed, so parts are keyed by id and
-     * only the terminal state produces a result.
+     * Emit one complete message part, once. OpenCode reports a tool part
+     * repeatedly as it moves through pending → running → completed, so parts are
+     * keyed by id and only the terminal state produces a result. A subagent's
+     * text is its report to the planner, not the reply, so it is dropped; the
+     * `task` call's result carries it.
      */
     private emitPart;
+    /**
+     * A `task` call runs a subagent in a child session. The call's part names
+     * that session once it exists, which is what ties the child's frames to the
+     * call; the subagent ends when the call does. The part is restated at every
+     * status change, and so is what it says here — the service reports each
+     * start and finish once, and no finish for a call that never had a child.
+     */
+    private trackSubagent;
+    /**
+     * One message's usage, once, when it has completed. Every assistant message
+     * is one model call; until it completes its counts are zeros.
+     */
+    private countUsage;
+    /**
+     * One `/event` frame. Only the planner's session and its children are
+     * followed: the server's stream is global, and another client's session is
+     * none of this turn's business.
+     */
+    private onFrame;
+    /**
+     * Stream one piece of a reply text part. The part's paragraph break goes out
+     * with its first visible delta, so the deltas add up to exactly the text the
+     * completed part then re-sends; a part that is only whitespace so far is
+     * held back, for the reason {@link emitPart} drops one.
+     */
+    private onTextDelta;
     /**
      * Deny one permission request (T1). OpenCode blocks the turn until the
      * request is answered, so this must answer — `reject` rather than a silent
@@ -2708,8 +2908,8 @@ declare class OpenCodeAdapter implements AgentAdapter {
      */
     private denyPermission;
     /**
-     * Server-sent events from `/event`. Tool activity on it is liveness only —
-     * the settled POST repeats it — but permission requests arrive nowhere else,
+     * Server-sent events from `/event`: the turn's live text, reasoning, tool
+     * activity and usage, and the only channel permission requests arrive on —
      * so the stream is load-bearing for {@link denyPermission}.
      */
     private streamEvents;
@@ -2935,6 +3135,13 @@ declare class Session {
     /** Injected by a test; when present it is the service, forever. */
     private readonly pinnedAiService?;
     private liveAiService;
+    private readonly usageLedger;
+    /**
+     * The in-flight turn's subagent activity, grouped one run per subagent so a
+     * replay nests each step under its own brief/result. Flushed into the plan's
+     * researchLog at persist — see {@link flushSubagentRuns}.
+     */
+    private pendingSubagents;
     private liveAiProvider;
     private readonly workspaceRootFn;
     private planner;
@@ -2995,6 +3202,18 @@ declare class Session {
     private buildObserver;
     private broadcastStatus;
     private translateProgress;
+    /** The run for `subagentId`, created on first sighting so a step arriving
+     * before (or without) its started event still gets a home. */
+    private subagentRun;
+    /**
+     * Fold the turn's subagent runs into the plan's researchLog as one contiguous
+     * group per subagent — its entry then its steps, in the order they started —
+     * so a replay nests each step under its own subagent however the live stream
+     * interleaved. A harness planner already logs its child steps through the
+     * turn's researchLog; they are pulled out of that position and re-grouped
+     * rather than duplicated.
+     */
+    private flushSubagentRuns;
     /** Persists PlanStore state to disk. PlanStore is the single authority;
      * LegacyPlanState.tasks is populated only here, at persist time. */
     private persist;
@@ -3051,6 +3270,12 @@ declare class Session {
     get currentPlanState(): PlanState | null;
     get currentGoal(): string;
     get isPlanning(): boolean;
+    /**
+     * A task is running right now. Deliberately live work, not the scheduler's
+     * armed flag: a run paused on a user task, a hold or a cancellation has
+     * nothing executing, and reporting it as executing is what left the plan
+     * unstartable after its last live task was cancelled.
+     */
     get isExecuting(): boolean;
     /** See {@link TaskOrchestrator.hasLiveWork} — a spawned runner, not merely an armed scheduler. */
     get hasLiveWork(): boolean;
@@ -3130,10 +3355,16 @@ declare class Session {
     private conversationOpening;
     /**
      * Load planner-produced tasks, coerced to the allowlist read live — it may
-     * have changed since planning started. An edit on an armed scheduler is
+     * have changed since planning started. Tasks adopted on an armed scheduler are
      * reconciled rather than reloaded: `loadPlan` clears the on-hold set and the
      * review approval, so a task the user cancelled would be re-armed and
      * re-spawned by the re-tick that follows.
+     *
+     * A whole-plan commit is the planner restating every task, so it is laid
+     * over the plan's execution state rather than replacing it: a planner that
+     * answers "add a task" with the full plan must not undo the work already
+     * done. Task ops need no overlay — their applier refuses to touch settled
+     * tasks, and `rearm`, the one op meant to change a status, must stand.
      */
     private adoptPlannerTasks;
     /**
@@ -3154,10 +3385,18 @@ declare class Session {
     markTaskIncomplete(taskId: string): Promise<void>;
     tick(): Promise<void>;
     processQueuedMessages(): Promise<void>;
+    /**
+     * Every finished task as the log records it: this run's own entries, plus
+     * the tasks earlier runs completed, which the log dropped when this run
+     * began but which dependents still count on.
+     */
+    private finishedWork;
     approveCheckpoint(taskId: string): void;
     rejectCheckpoint(taskId: string, reason?: string): void;
     queueMessage(text: string): void;
     getQueuedMessages(): QueuedMessage[];
+    /** Take back one unsent message; the plan's persisted queue follows so a reload cannot resurrect it. */
+    removeQueuedMessage(id: string): boolean;
     setQueuedMessages(msgs: ReturnType<TaskOrchestrator['getQueuedMessages']>): void;
     processNextQueuedMessage(): QueuedMessage | null;
     get queuedCount(): number;
@@ -3598,11 +3837,12 @@ declare function buildConflictRepairPrompt(task: Task, conflict: {
  *
  * - {@link repairLoop} is the bounded driver (first reply → interpret →
  *   corrective re-send), used by plan generation ({@link generatePlanWithRepair}),
- *   the Session's task-ops settlement, and Planner.modifyDuringExecution.
+ *   the Session's task-ops settlement, Planner.modifyDuringExecution, and
+ *   `settleReply` — the one loop both planner backends settle a conversation
+ *   turn's reply through.
  * - {@link classifyPlannerReply} decides what a planner reply *is* — a plan,
  *   targeted task edits, a botched attempt at either (worth a corrective
- *   retry), or prose. The conversation loop in BaseAiService keeps its own
- *   driver (it also runs the tool rounds) but delegates classification here.
+ *   retry), or prose.
  * - The corrective prompt texts live here, once.
  *
  * Policies stay at the call sites (ops validation, abort guards) —
@@ -3610,10 +3850,15 @@ declare function buildConflictRepairPrompt(task: Task, conflict: {
  */
 type RepairVerdict<T> = {
     done: T;
-} | {
+}
+/**
+ * A corrective that costs something to prepare (freeing context first) is
+ * passed as a function: it runs only when a re-send will actually follow.
+ */
+ | {
     retry: {
         errors: string[];
-        corrective: string;
+        corrective: string | (() => string);
         cause?: unknown;
     };
 };
@@ -3776,6 +4021,9 @@ declare class TmuxSession extends AbstractTerminalSession {
     private outputBuffer;
     private offset;
     private timer;
+    private quietPolls;
+    private misses;
+    private looking;
     constructor(id: string, taskId: string, tmuxSession: string, windowName: string, execFileImpl: ExecFileFn, pollIntervalMs: number, logPath: string, socket: string);
     private get target();
     /** Every tmux call must name the daemon's own socket; an unprefixed one
@@ -3790,6 +4038,18 @@ declare class TmuxSession extends AbstractTerminalSession {
      */
     start(command: string, args: string[], cwd: string, env?: Record<string, string>): Promise<void>;
     private poll;
+    /** Emit what the log gained since the last read; false when it gained nothing. */
+    private readLog;
+    /**
+     * The sentinel is printed by the wrapper shell, so a window closed from
+     * outside — killed by the user, or with the whole tmux server — never prints
+     * it, and the session would count as running forever. A silent window is
+     * therefore looked up by exact name (a `-t` target falls back to another
+     * window once its own is gone), and once it is confirmed missing the session
+     * ends as a kill does. Whatever the log still held is read first, so a
+     * completion marker printed just before the close still counts.
+     */
+    private checkWindow;
     /**
      * A task finishing (or being killed) stops observation, but never the
      * window itself on the sentinel path — only `kill()` closes the window.
@@ -4256,4 +4516,4 @@ declare const DEFAULT_MAX_PARALLEL = 3;
  */
 declare function parseMaxParallel(value: unknown): number | null;
 
-export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalMode, ApprovalRequest, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationBusyError, type ConversationCompaction, ConversationEditError, type ConversationFork, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationTurn, type ConversationVariant, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, DiscoveredModel, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecFileFn, type ExecImpl, ExecutableNotFoundError, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, type GitExecFn, GlobOptions, type GrepInvocation, GrepOptions, type HasBinFn, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, HomeTranscriptReader, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, IWorktreeIsolation, IsolationHandoff, IsolationLandedTask, IsolationMergeResult, IsolationView, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type LiveOutputLookup, type LiveTail, type LiveTailOptions, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PluginSource, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, type PtySize, type PtyWrapOptions, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, RepoGroupLayout, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, ResolveContext, type RewindTarget, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionMeta, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, type TaskAttemptSnapshot, TaskIsolation, TaskOp, TaskOrchestrator, type TaskOutputAttempt, type TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type TranscriptQuery, type TranscriptReader, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConflictRepairPrompt, buildConflictResolutionPrompt, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, createSkillsService, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, describeMergeResult, discoverGeminiModels, effectiveAllowlist, ensureDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, parseMaxParallel, parseTaskQueryJson, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };
+export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalMode, ApprovalRequest, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationBusyError, type ConversationCompaction, ConversationEditError, type ConversationFork, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationTurn, type ConversationVariant, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, DiscoveredModel, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecFileFn, type ExecImpl, ExecutableNotFoundError, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, type GitExecFn, GlobOptions, type GrepInvocation, GrepOptions, type HasBinFn, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, HomeTranscriptReader, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, IWorktreeIsolation, IsolationHandoff, IsolationLandedTask, IsolationMergeResult, IsolationView, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type LiveOutputLookup, type LiveTail, type LiveTailOptions, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PluginSource, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, type PtySize, type PtyWrapOptions, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, RepoGroupLayout, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, ResolveContext, type RewindTarget, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionMeta, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, SubagentOutcome, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, type TaskAttemptSnapshot, TaskIsolation, TaskOp, TaskOrchestrator, type TaskOutputAttempt, type TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type TranscriptQuery, type TranscriptReader, UsageRecord, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConflictRepairPrompt, buildConflictResolutionPrompt, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, createSkillsService, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, describeMergeResult, discoverGeminiModels, effectiveAllowlist, ensureDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, parseMaxParallel, parseTaskQueryJson, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };