@ordewell/core 0.7.0 → 0.7.2

package/dist/{Task-CoKhvBa1.d.ts → Task-BpzIbunq.d.ts}

@@ -301,18 +301,49 @@ interface PreparedTask {
      * stay in the task, so the user is told.
      */
     copied: string[];
+    /** What the attempt this one replaces left unlanded, kept on a branch before its worktree went; absent when nothing was. */
+    preserved?: PreservedWork[];
+}
+/** A task as a removal names it. */
+type IsolationTaskRef = Pick<IsolationTaskRecord, 'taskId' | 'order' | 'title'>;
+/**
+ * Work a removal found that had not landed — edits never committed, or
+ * commits only the task's branch carried — committed and kept on `branch`,
+ * a branch of its own under `ordewell-preserved/`, before the worktree went.
+ */
+interface PreservedWork {
+    /** Absent for a leftover directory no task record owned. */
+    task?: IsolationTaskRef;
+    repo: string;
+    branch: string;
+    /** The commit `branch` points at. */
+    commit: string;
+}
+/** A worktree a removal left in place, because the work in it could not be kept any other way. */
+interface RefusedRemoval {
+    /** Absent for a leftover directory no task record owned. */
+    task?: IsolationTaskRef;
+    worktree: string;
+    /** What stopped git keeping it, in words a surface can repeat. */
+    reason: string;
+}
+/**
+ * What removing task worktrees did in place of deleting work. A removal never
+ * deletes work that has not landed: it keeps it on a branch first
+ * (`preserved`), and where it cannot, it leaves that worktree alone
+ * (`refused`) — so the record of a refused task stays too.
+ */
+interface IsolationRemoval {
+    preserved: PreservedWork[];
+    refused: RefusedRemoval[];
 }
 /**
  * What a crash-recovery prune found and left alone: task records that were
  * `active` yet still held unlanded work, so the prune kept them as `kept`
  * rather than deleting work no one else has.
  */
-interface IsolationPruneResult {
-    kept: Array<{
-        taskId: string;
-        order: number;
-        title: string;
-    }>;
+interface IsolationPruneResult extends IsolationRemoval {
+    kept: IsolationTaskRef[];
 }
 /**
  * The tracked changes of a workspace's repos at one moment, against each
@@ -379,7 +410,9 @@ interface IWorktreeIsolation {
     integrate(task: Task, run: IsolationRun, persist?: () => void): Promise<IsolationOutcome>;
     /**
      * `keep: false` removes the task's worktree, branch and record (retry, task
-     * removal). `keep: true` leaves the worktree and branch exactly as they are
+     * removal), keeping whatever had not landed on a branch first; a record
+     * whose work cannot be kept stays, off `active`. `keep: true` leaves the
+     * worktree and branch exactly as they are
      * for inspection — a failed verdict, a stop, a cancel — and only moves the task off `active`,
      * so a crash-recovery prune does not sweep it away; a repair it ends leaves
      * the task `conflict`, as it was before the repair. Takes the run rather than
@@ -388,7 +421,7 @@ interface IWorktreeIsolation {
      */
     release(run: IsolationRun, taskId: string, opts: {
         keep: boolean;
-    }): Promise<void>;
+    }): Promise<IsolationRemoval>;
     /** End of run: park the integration branch for review and report what landed. */
     handoff(run: IsolationRun): Promise<IsolationHandoff>;
     /**
@@ -398,7 +431,8 @@ interface IWorktreeIsolation {
      * that still holds unlanded work — commits its branch alone carries, or
      * edits in its worktree — is not a crash orphan: it may belong to a runner
      * another host is still driving, so it is kept as `kept` and named in the
-     * result.
+     * result. A leftover directory holding work is kept on a branch before it
+     * goes, as {@link release} does.
      */
     pruneOrphans(run: IsolationRun): Promise<IsolationPruneResult>;
     /** Unified diff of each repo's integration branch against its base ref. */
@@ -436,11 +470,12 @@ interface IWorktreeIsolation {
     /**
      * Remove every worktree and task branch of the run, and settle each repo's
      * integration branch as `integration` says. Anything but `keep` also clears
-     * the run's task records.
+     * the run's task records, except those of worktrees it refused to remove.
+     * Work that had not landed is kept on a branch first, as {@link release} does.
      */
     discard(run: IsolationRun, opts: {
         integration: IntegrationDisposal;
-    }): Promise<void>;
+    }): Promise<IsolationRemoval>;
     /**
      * Clear what other runs left in each repo of `run`'s group: every
      * `ordewell/<run-id>/…` branch the repo's checked-out HEAD already contains.
@@ -678,6 +713,8 @@ type SpawnFn = (command: string, args: string[], options: {
     cwd: string;
     /** Set by the Windows batch route, where `args` is already a quoted command line. */
     windowsVerbatimArguments?: boolean;
+    /** Set on POSIX so the runner leads its own process group (see `spawnInOwnGroup`). */
+    detached?: boolean;
 }) => ChildProcess;
 /** Test seam: every OS touchpoint is injectable; production uses the defaults. */
 interface HeadlessRunnerDeps {
@@ -695,10 +732,11 @@ interface HeadlessRunnerDeps {
 declare class HeadlessSession extends AbstractTerminalSession {
     private spawnImpl;
     readonly interactive: boolean;
+    private platform;
     private process;
     private outputBuffer;
     private controlStream;
-    constructor(id: string, taskId: string, spawnImpl: SpawnFn, interactive?: boolean);
+    constructor(id: string, taskId: string, spawnImpl: SpawnFn, interactive?: boolean, platform?: NodeJS.Platform);
     get isStarted(): boolean;
     start(launch: LaunchPlan, cwd: string, resolvedPath: string, env?: Record<string, string>, options?: {
         controlChannel?: boolean;
@@ -1081,6 +1119,8 @@ interface McpTool<H> {
     /** Validate `args` and hand them to the handler's method for this tool. */
     call(handler: H, args: unknown, context: McpToolContext): Promise<McpToolReply>;
 }
+/** The task tool whose call settles the attempt (ADR-0022, V1). */
+declare const TASK_COMPLETE_TOOL = "task_complete";
 declare const TASK_TOOLS: readonly McpTool<TaskToolHandler>[];
 declare const PLANNER_TOOLS: readonly McpTool<PlannerToolHandler>[];
 
@@ -1284,6 +1324,24 @@ type AgentEvent =
     type: 'turn_end';
     interrupted?: boolean;
 }
+/**
+ * The model has a message handed over by {@link TaskModeAgentAdapter.steer},
+ * by the runner's own account rather than because the write succeeded
+ * (ADR-0023, D3). With no turn open, the runner opened one for it.
+ */
+ | {
+    type: 'message_delivered';
+    id: string;
+}
+/**
+ * The runner let go of a message it accepted from `steer` without showing it
+ * to the model — Codex does, for one its turn ended before consuming. It is
+ * Ordewell's to send again (ADR-0023, D4).
+ */
+ | {
+    type: 'message_dropped';
+    id: string;
+}
 /** The turn failed. Carries the agent's own words — never a Ordewell paraphrase. */
  | {
     type: 'error';
@@ -1396,6 +1454,16 @@ interface TaskModeAgentAdapter extends AgentAdapter {
     onOutOfTurn?(listener: (event: AgentEvent) => void): void;
     /** Registers a listener for the process ending, for any reason. Fires at most once. */
     onProcessExit(listener: (code: number) => void): void;
+    /**
+     * Hand a message to the running turn, for the runner to show the model at
+     * its next step boundary (ADR-0023, D1–D2). Resolves true once the runner
+     * accepted it: handed over, not yet delivered — the turn's events later
+     * carry `message_delivered` or `message_dropped` for `id`. False when the
+     * runner refused it or no turn is running; the caller keeps it for the
+     * turn's end. Absent on an adapter whose runner cannot take a message
+     * mid-turn.
+     */
+    steer?(id: string, text: string): Promise<boolean>;
     /**
      * Answer an open `permission_request`. False when the id is not open — it
      * was answered, cancelled, or never asked.
@@ -1976,25 +2044,49 @@ type StructuredTurnEnd = 'completed' | 'interrupted' | 'failed';
  * full-fidelity task log, never for verdicts.
  */
 type StructuredEvent = Exclude<AgentEvent, {
-    type: 'turn_end';
-} | {
-    type: 'permission_cancelled';
+    type: 'turn_end' | 'permission_cancelled' | 'message_delivered' | 'message_dropped';
 }>
-/** `text` is the user message the turn answers; `messageId` is set when it had waited in the queue. */
+/**
+ * `text` is the user message the turn answers; `messageId` is set when it had
+ * waited in the queue, `forced` when it was force sent (ADR-0023, Q2).
+ */
  | {
     type: 'turn_start';
     text: string;
     messageId?: string;
+    forced?: boolean;
 } | {
     type: 'turn_end';
     reason: StructuredTurnEnd;
-} | {
+}
+/**
+ * Waiting in Ordewell's queue — again, for a message the runner was handed
+ * and let go of (ADR-0023, D4). `forced` puts it ahead of the rest, behind
+ * earlier forced ones (F2); a message already listed moves there.
+ */
+ | {
     type: 'message_queued';
     messageId: string;
     text: string;
+    forced?: boolean;
 } | {
     type: 'message_removed';
     messageId: string;
+} | {
+    type: 'message_undelivered';
+    messageId: string;
+    text: string;
+}
+/** The runner accepted the message into its running turn; it can no longer be taken back (ADR-0023, D3). */
+ | {
+    type: 'message_handed_over';
+    messageId: string;
+}
+/** The model read the message inside the running turn, at this point of it (ADR-0023, Q2). */
+ | {
+    type: 'message_delivered';
+    messageId: string;
+    text: string;
 }
 /** An open `permission_request` was answered, by whoever answered it (ADR-0018, A1). */
  | {
@@ -2010,6 +2102,10 @@ type StructuredEvent = Exclude<AgentEvent, {
 interface QueuedTaskMessage {
     id: string;
     text: string;
+    /** The runner has it and owes a delivery, so it cannot be taken back (ADR-0023, Q1). */
+    handedOver?: boolean;
+    /** Force sent: it goes out as soon as the running turn is interrupted (ADR-0023, F1). */
+    forced?: boolean;
 }
 /**
  * What a session driven over its runner's protocol can do that a terminal
@@ -2023,13 +2119,23 @@ interface StructuredSessionCapability {
     onTurnEnd(listener: (reason: StructuredTurnEnd) => void): void;
     onEvent(listener: (event: StructuredEvent) => void): void;
     /**
-     * Queue a user message, delivered when the current turn ends — or at once
-     * when idle. Returns its id, for {@link removeQueued}.
+     * Send a user message: at once when idle; while a turn runs, handed to the
+     * runner for its next step where it can take one, otherwise queued until
+     * the turn ends (ADR-0023). Returns its id, for {@link removeQueued}.
      */
     sendMessage(text: string): string;
-    /** Take a message back before it is delivered. False when it already was. */
+    /**
+     * Force send (ADR-0023, F1–F3): interrupt the running turn, as
+     * {@link interrupt} does, and deliver this message as the turn that
+     * replaces it, ahead of anything still queued. The task does not wait for
+     * input in between. With no turn running it is {@link sendMessage}.
+     */
+    forceSend(text: string): string;
+    /** Force send a message still queued, by id. False once it was handed over or delivered. */
+    forceSendQueued(id: string): boolean;
+    /** Take a message back before the runner has it. False once it was handed over or delivered. */
     removeQueued(id: string): boolean;
-    /** Messages waiting for the current turn to end, oldest first. */
+    /** Messages not yet delivered, oldest first: queued ones, and ones handed over that the runner owes. */
     queued(): QueuedTaskMessage[];
     /**
      * Stop the running turn, keeping the session: a soft interrupt first, then —
@@ -2432,6 +2538,24 @@ declare function migratePlanState(raw: unknown): PlanState;
 declare function migrateLegacyPlan(legacy: LegacyPlanState): PlanState;
 
 declare function createTask(overrides?: Partial<Task>): Task;
+/**
+ * The `ops` flag as a task stores it (ADR-0020), however it arrived. Only a
+ * literal `true` on an AI task marks an ops task: the planner's JSON is
+ * untyped, and a quoted "true" read as ops would move a task out of its
+ * worktree. Anything else is a change task, stored absent so saved plans need
+ * no migration. Whether the task may be ops at all — a subtask may not — is
+ * for whoever knows where it sits: parsing drops the flag, an edit refuses it.
+ */
+declare function opsFlag(value: unknown, type?: Task['type']): true | undefined;
+/**
+ * The flag of a task a merge or a split makes from others: what the edit
+ * chose, else ops only when every task it came from was. A merge that takes
+ * in a change edits files, so it is a change; a split part runs where its
+ * task did.
+ */
+declare function inheritedOps(from: readonly Pick<Task, 'ops'>[], chosen?: boolean): boolean;
+/** The runner set a plan has until one is chosen: the one runner every host ships. */
+declare const DEFAULT_RUNNERS: readonly RunnerId[];
 declare function createEmptyPlan(): LegacyPlanState;
 declare function flattenTasks(tasks: readonly Task[]): Task[];
 /** A flattened task with the parent it hangs under, null for a top-level task. */
@@ -2472,4 +2596,4 @@ interface ValidationContext {
 type ValidationCheck = (ctx: ValidationContext) => ValidationResult;
 declare function warningsText(w: PlanModificationWarnings): string | null;
 
-export { type IsolationOutcome as $, AbstractRunner as A, type BlockingPrompt as B, CMD_EXE_MAX_COMMAND_LINE as C, DENY_ALL as D, type EditPlanArgs as E, EmbeddedNewlineError as F, ExecutableNotFoundError as G, type FetchAllProviderModelsOptions as H, HeadlessRunner as I, type HeadlessRunnerDeps as J, HeadlessSession as K, type IApproval as L, type IConfig as M, type IPluginStore as N, type ITerminalRunner as O, type ITerminalSession as P, type IWorktreeIsolation as Q, type IntegrationDisposal as R, type IsolationAvailability as S, type IsolationHandoff as T, type IsolationHandoffRepo as U, type IsolationInactiveReason as V, type IsolationLandedTask as W, type IsolationLanding as X, type IsolationMergeBlock as Y, type IsolationMergeBlockReason as Z, type IsolationMergeResult as _, AbstractTerminalSession as a, type RunnerSpawnOptions as a$, type IsolationPruneResult as a0, type IsolationRepo as a1, type IsolationRun as a2, type IsolationTaskRecord as a3, type IsolationTaskRepo as a4, type IsolationTaskStatus as a5, type IsolationView as a6, type LaunchDeps as a7, type LaunchPlan as a8, type LegacyPlanState as a9, type PluginCloneFn as aA, type PluginEntry as aB, type PluginFeatures as aC, type PluginMode as aD, type PluginModelDiscovery as aE, type PluginRunnerDef as aF, type PreparedLaunch as aG, type PreparedTask as aH, type ProviderCredentialSource as aI, type ProviderModelLists as aJ, type ProviderModelsResult as aK, type PtySize as aL, type PtyWrapOptions as aM, type QueuedMessage as aN, type QueuedTaskMessage as aO, type RepairEvidence as aP, type RepoGroupLayout as aQ, type ResearchLogEntry as aR, type ResearchProgress as aS, type ResearchStep as aT, type ResearchStepOutcome as aU, type ResearchToolType as aV, type ResolveContext as aW, type RunnerId as aX, type RunnerInvocation as aY, type RunnerPluginManifest as aZ, RunnerRegistry as a_, LineBuffer as aa, type ListModelsArgs as ab, type ListRunnersArgs as ac, type McpClientConfig as ad, type McpCredential as ae, type McpTool as af, type McpToolContext as ag, type McpToolReply as ah, type Message as ai, ModelCatalog as aj, type ModelShortcut as ak, ORCHESTRATOR_SHORTCUTS as al, ORDEWELL_MCP_PATH as am, ORDEWELL_MCP_SERVER_NAME as an, type OrchestratorOption as ao, OrdewellMcpServer as ap, type OwnerOnlyFile as aq, PLANNER_TOOLS as ar, type PlanIsolation as as, type PlanModificationWarnings as at, type PlanState as au, type PlanStatus as av, type PlannerStartOptions as aw, type PlannerTokenScope as ax, type PlannerToolHandler as ay, type PlannerUsage as az, type ActiveTaskSession as b, isRunnerApproval as b$, type RunnerTransport as b0, type RunnerVersionProbe as b1, type StreamEvent as b2, type StreamStepEvent as b3, type StreamThinkingEvent as b4, type StructuredEvent as b5, type StructuredSessionCapability as b6, type StructuredTurnEnd as b7, type SubagentLogEntry as b8, type SubagentOutcome as b9, type UsageTotals as bA, type UserPromptEntry as bB, type UserStep as bC, type ValidationCheck as bD, type ValidationContext as bE, type ValidationResult as bF, type Verdict as bG, type VerificationCheck as bH, WINDOWS_MAX_COMMAND_LINE as bI, addPlannerUsage as bJ, addTaskToPlan as bK, addUsage as bL, approvalScopes as bM, buildShellInvocation as bN, collectProviderCredentials as bO, createEmptyPlan as bP, createTask as bQ, emptyWarnings as bR, enabledRunners as bS, fetchAllProviderModels as bT, flattenTasks as bU, flattenTasksWithParents as bV, isAwaitingReason as bW, isExecutableResolved as bX, isGranted as bY, isMeasured as bZ, isReservedRunnerName as b_, type SubmitPlanArgs as ba, TASK_TOOLS as bb, type Task as bc, type TaskCompleteArgs as bd, type TaskIsolation as be, type TaskIsolationState as bf, type TaskMode as bg, type TaskModeAgentAdapter as bh, TaskModeUnsupportedError as bi, type TaskModelAssignment as bj, type TaskOutputArgs as bk, type TaskOutputSummary as bl, type TaskQueryArgs as bm, type TaskRunnerFlags as bn, type TaskSnapshot as bo, type TaskStartOptions as bp, type TaskStatus as bq, type TaskTokenScope as br, type TaskToolHandler as bs, type TaskTransport as bt, type TaskType as bu, type TaskWithParent as bv, type ThinkingBlock as bw, type TreeSnapshot as bx, type UsageLine as by, type UsageRecord as bz, type AgentAdapter as c, isRunnerTransport as c0, isStructuredSession as c1, keepExecutionState as c2, knownModelId as c3, mcpClientConfig as c4, migrateLegacyPlan as c5, migratePlanState as c6, migrateTask as c7, ownerOnlyConfigFile as c8, partedPromptUsage as c9, planDirectLaunch as ca, planShellLaunch as cb, plannerContextFill as cc, posixShellQuote as cd, removeTaskFromPlan as ce, renumberTasks as cf, resolveModelShortcut as cg, resolveProvider as ch, sharedMcpServer as ci, stripAnsi as cj, toApprovalDecision as ck, toOrchestratorOptions as cl, updateTaskInPlan as cm, usageLine as cn, validateModifiedPlan as co, warningsText as cp, windowsCommandLine as cq, wrapWithPty as cr, type AgentAdapterFactory as d, type AgentEvent as e, type AgentProcessDeps as f, type AgentStartOptions as g, type AiProvider as h, type AllProviderModels as i, type ApprovalAnswer as j, type ApprovalDecision as k, type ApprovalKind as l, type ApprovalMode as m, ApprovalPolicy as n, type ApprovalPolicyOptions as o, type ApprovalRequest as p, type ApprovalSource as q, type AwaitingReason as r, type CatalogModel as s, type CheckpointAnswer as t, type CheckpointArgs as u, CommandLineTooLongError as v, type ConversationMessage as w, type DiscoveredMode as x, type DiscoveredModel as y, type DiscoveryCommand as z };
+export { type IsolationMergeResult as $, AbstractRunner as A, type BlockingPrompt as B, CMD_EXE_MAX_COMMAND_LINE as C, DEFAULT_RUNNERS as D, type DiscoveryCommand as E, type EditPlanArgs as F, EmbeddedNewlineError as G, ExecutableNotFoundError as H, type FetchAllProviderModelsOptions as I, HeadlessRunner as J, type HeadlessRunnerDeps as K, HeadlessSession as L, type IApproval as M, type IConfig as N, type IPluginStore as O, type ITerminalRunner as P, type ITerminalSession as Q, type IWorktreeIsolation as R, type IntegrationDisposal as S, type IsolationAvailability as T, type IsolationHandoff as U, type IsolationHandoffRepo as V, type IsolationInactiveReason as W, type IsolationLandedTask as X, type IsolationLanding as Y, type IsolationMergeBlock as Z, type IsolationMergeBlockReason as _, AbstractTerminalSession as a, type ResolveContext as a$, type IsolationOutcome as a0, type IsolationPruneResult as a1, type IsolationRemoval as a2, type IsolationRepo as a3, type IsolationRun as a4, type IsolationTaskRecord as a5, type IsolationTaskRef as a6, type IsolationTaskRepo as a7, type IsolationTaskStatus as a8, type IsolationView as a9, type PlannerTokenScope as aA, type PlannerToolHandler as aB, type PlannerUsage as aC, type PluginCloneFn as aD, type PluginEntry as aE, type PluginFeatures as aF, type PluginMode as aG, type PluginModelDiscovery as aH, type PluginRunnerDef as aI, type PreparedLaunch as aJ, type PreparedTask as aK, type PreservedWork as aL, type ProviderCredentialSource as aM, type ProviderModelLists as aN, type ProviderModelsResult as aO, type PtySize as aP, type PtyWrapOptions as aQ, type QueuedMessage as aR, type QueuedTaskMessage as aS, type RefusedRemoval as aT, type RepairEvidence as aU, type RepoGroupLayout as aV, type ResearchLogEntry as aW, type ResearchProgress as aX, type ResearchStep as aY, type ResearchStepOutcome as aZ, type ResearchToolType as a_, type LaunchDeps as aa, type LaunchPlan as ab, type LegacyPlanState as ac, LineBuffer as ad, type ListModelsArgs as ae, type ListRunnersArgs as af, type McpClientConfig as ag, type McpCredential as ah, type McpTool as ai, type McpToolContext as aj, type McpToolReply as ak, type Message as al, ModelCatalog as am, type ModelShortcut as an, ORCHESTRATOR_SHORTCUTS as ao, ORDEWELL_MCP_PATH as ap, ORDEWELL_MCP_SERVER_NAME as aq, type OrchestratorOption as ar, OrdewellMcpServer as as, type OwnerOnlyFile as at, PLANNER_TOOLS as au, type PlanIsolation as av, type PlanModificationWarnings as aw, type PlanState as ax, type PlanStatus as ay, type PlannerStartOptions as az, type ActiveTaskSession as b, flattenTasksWithParents as b$, type RunnerId as b0, type RunnerInvocation as b1, type RunnerPluginManifest as b2, RunnerRegistry as b3, type RunnerSpawnOptions as b4, type RunnerTransport as b5, type RunnerVersionProbe as b6, type StreamEvent as b7, type StreamStepEvent as b8, type StreamThinkingEvent as b9, type TaskType as bA, type TaskWithParent as bB, type ThinkingBlock as bC, type TreeSnapshot as bD, type UsageLine as bE, type UsageRecord as bF, type UsageTotals as bG, type UserPromptEntry as bH, type UserStep as bI, type ValidationCheck as bJ, type ValidationContext as bK, type ValidationResult as bL, type Verdict as bM, type VerificationCheck as bN, WINDOWS_MAX_COMMAND_LINE as bO, addPlannerUsage as bP, addTaskToPlan as bQ, addUsage as bR, approvalScopes as bS, buildShellInvocation as bT, collectProviderCredentials as bU, createEmptyPlan as bV, createTask as bW, emptyWarnings as bX, enabledRunners as bY, fetchAllProviderModels as bZ, flattenTasks as b_, type StructuredEvent as ba, type StructuredSessionCapability as bb, type StructuredTurnEnd as bc, type SubagentLogEntry as bd, type SubagentOutcome as be, type SubmitPlanArgs as bf, TASK_COMPLETE_TOOL as bg, TASK_TOOLS as bh, type Task as bi, type TaskCompleteArgs as bj, type TaskIsolation as bk, type TaskIsolationState as bl, type TaskMode as bm, type TaskModeAgentAdapter as bn, TaskModeUnsupportedError as bo, type TaskModelAssignment as bp, type TaskOutputArgs as bq, type TaskOutputSummary as br, type TaskQueryArgs as bs, type TaskRunnerFlags as bt, type TaskSnapshot as bu, type TaskStartOptions as bv, type TaskStatus as bw, type TaskTokenScope as bx, type TaskToolHandler as by, type TaskTransport as bz, type AgentAdapter as c, inheritedOps as c0, isAwaitingReason as c1, isExecutableResolved as c2, isGranted as c3, isMeasured as c4, isReservedRunnerName as c5, isRunnerApproval as c6, isRunnerTransport as c7, isStructuredSession as c8, keepExecutionState as c9, knownModelId as ca, mcpClientConfig as cb, migrateLegacyPlan as cc, migratePlanState as cd, migrateTask as ce, opsFlag as cf, ownerOnlyConfigFile as cg, partedPromptUsage as ch, planDirectLaunch as ci, planShellLaunch as cj, plannerContextFill as ck, posixShellQuote as cl, removeTaskFromPlan as cm, renumberTasks as cn, resolveModelShortcut as co, resolveProvider as cp, sharedMcpServer as cq, stripAnsi as cr, toApprovalDecision as cs, toOrchestratorOptions as ct, updateTaskInPlan as cu, usageLine as cv, validateModifiedPlan as cw, warningsText as cx, windowsCommandLine as cy, wrapWithPty as cz, type AgentAdapterFactory as d, type AgentEvent as e, type AgentProcessDeps as f, type AgentStartOptions as g, type AiProvider as h, type AllProviderModels as i, type ApprovalAnswer as j, type ApprovalDecision as k, type ApprovalKind as l, type ApprovalMode as m, ApprovalPolicy as n, type ApprovalPolicyOptions as o, type ApprovalRequest as p, type ApprovalSource as q, type AwaitingReason as r, type CatalogModel as s, type CheckpointAnswer as t, type CheckpointArgs as u, CommandLineTooLongError as v, type ConversationMessage as w, DENY_ALL as x, type DiscoveredMode as y, type DiscoveredModel as z };