@ordewell/core 0.6.4 → 0.7.1

package/dist/{Task-xqdxugt2.d.mts → Task-BnLxkVQF.d.mts}

@@ -1,5 +1,6 @@
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
+import { z } from 'zod/v4';
 
 /**
  * Why isolated execution is unavailable for a workspace. The orchestrator needs
@@ -300,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
@@ -378,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
@@ -387,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>;
     /**
@@ -397,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. */
@@ -435,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.
@@ -914,6 +950,250 @@ interface IApproval {
 /** Denies everything. The safe default when a surface wires no approval channel. */
 declare const DENY_ALL: IApproval;
 
+/**
+ * The tools of the Ordewell MCP server, per token role (ADR-0022), and the
+ * handler interfaces the session side implements to answer them.
+ *
+ * Every handler method is optional so each tool can be wired on its own; one
+ * left unset answers its call with a "not available" error rather than
+ * disappearing from `tools/list`, so the list a runner sees never depends on
+ * how far the wiring has got.
+ */
+declare const taskCompleteInput: z.ZodObject<{
+    status: z.ZodEnum<{
+        failed: "failed";
+        blocked: "blocked";
+        done: "done";
+    }>;
+    summary: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const checkpointInput: z.ZodObject<{
+    question: z.ZodString;
+}, z.core.$strip>;
+declare const listRunnersInput: z.ZodObject<{}, z.core.$strip>;
+declare const listModelsInput: z.ZodObject<{
+    runner: z.ZodString;
+}, z.core.$strip>;
+declare const submitPlanInput: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodNumber>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<{
+            user: "user";
+            ai: "ai";
+        }>>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prompt: z.ZodOptional<z.ZodString>;
+        userSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            order: z.ZodOptional<z.ZodNumber>;
+            instruction: z.ZodString;
+        }, z.core.$loose>>>;
+        assignedRunner: z.ZodOptional<z.ZodString>;
+        assignedModel: z.ZodOptional<z.ZodObject<{
+            modelId: z.ZodString;
+            modelLabel: z.ZodOptional<z.ZodString>;
+            thinkingEffort: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        taskMode: z.ZodOptional<z.ZodString>;
+        autonomy: z.ZodOptional<z.ZodEnum<{
+            AFK: "AFK";
+            HITL: "HITL";
+        }>>;
+        sliceType: z.ZodOptional<z.ZodEnum<{
+            AFK: "AFK";
+            HITL: "HITL";
+        }>>;
+        ops: z.ZodOptional<z.ZodBoolean>;
+        userStoriesCovered: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        subtasks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+declare const editPlanInput: z.ZodObject<{
+    ops: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"update">;
+        taskId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        changes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"add">;
+        task: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        handle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"remove">;
+        taskId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"reorder">;
+        taskIds: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"merge">;
+        taskIds: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        merged: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        handle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"split">;
+        taskId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        parts: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        handle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"rearm">;
+        taskId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+declare const taskQueryInput: z.ZodObject<{
+    tasks: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        description: "description";
+        prompt: "prompt";
+        userSteps: "userSteps";
+        verdict: "verdict";
+        outputSummary: "outputSummary";
+        userStoriesCovered: "userStoriesCovered";
+    }>>>;
+    catalog: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const taskOutputInput: z.ZodObject<{
+    task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    lines: z.ZodOptional<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type TaskCompleteArgs = z.infer<typeof taskCompleteInput>;
+type CheckpointArgs = z.infer<typeof checkpointInput>;
+type ListRunnersArgs = z.infer<typeof listRunnersInput>;
+type ListModelsArgs = z.infer<typeof listModelsInput>;
+type SubmitPlanArgs = z.infer<typeof submitPlanInput>;
+type EditPlanArgs = z.infer<typeof editPlanInput>;
+type TaskQueryArgs = z.infer<typeof taskQueryInput>;
+type TaskOutputArgs = z.infer<typeof taskOutputInput>;
+/** What a handler answers with. `isError` marks a refusal the caller should act on. */
+interface McpToolReply {
+    text: string;
+    isError?: boolean;
+}
+/**
+ * How a checkpoint call ended. `withdrawn` is the attempt going away under it
+ * (verdict, cancel, retry, stop) or the call being refused, not a verdict on
+ * the question.
+ */
+type CheckpointAnswer = {
+    kind: 'continue';
+} | {
+    kind: 'rejected';
+    reason: string;
+} | {
+    kind: 'withdrawn';
+    why: string;
+};
+interface McpToolContext {
+    /** Aborts when the token is revoked or the caller cancels — a waiting handler must stop. */
+    signal: AbortSignal;
+}
+type Run<A> = (args: A, context: McpToolContext) => Promise<McpToolReply>;
+interface TaskToolHandler {
+    taskComplete?: Run<TaskCompleteArgs>;
+    checkpoint?: Run<CheckpointArgs>;
+}
+interface PlannerToolHandler {
+    listRunners?: Run<ListRunnersArgs>;
+    listModels?: Run<ListModelsArgs>;
+    submitPlan?: Run<SubmitPlanArgs>;
+    editPlan?: Run<EditPlanArgs>;
+    taskQuery?: Run<TaskQueryArgs>;
+    taskOutput?: Run<TaskOutputArgs>;
+}
+interface McpTool<H> {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        [key: string]: unknown;
+    };
+    annotations?: {
+        readOnlyHint: boolean;
+    };
+    /** 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>[];
+
+/**
+ * The Ordewell MCP server (ADR-0022): one loopback listener per process,
+ * shared by every session in it, where the caller's token alone decides which
+ * tools it sees and which session and task its calls reach.
+ */
+declare const ORDEWELL_MCP_PATH = "/mcp";
+interface OrdewellMcpServerOptions {
+    /** How often a call that is still waiting tells its caller so. */
+    heartbeatMs?: number;
+}
+interface TaskTokenScope {
+    sessionId: string;
+    taskId: string;
+    /** The attempt generation the token is good for; a later attempt gets a new token. */
+    attempt: number;
+}
+interface PlannerTokenScope {
+    sessionId: string;
+}
+/** Where a runner reaches the server and what it presents there. Never put either half in a prompt. */
+interface McpCredential {
+    url: string;
+    token: string;
+}
+declare class OrdewellMcpServer {
+    private readonly grants;
+    private http;
+    private listening;
+    private boundUrl;
+    private boundHost;
+    private readonly heartbeatMs;
+    constructor(options?: OrdewellMcpServerOptions);
+    /** The listener's URL, once the first token has started it. */
+    get url(): string | undefined;
+    issueTaskToken(scope: TaskTokenScope, handler?: TaskToolHandler): Promise<McpCredential>;
+    issuePlannerToken(scope: PlannerTokenScope, handler?: PlannerToolHandler): Promise<McpCredential>;
+    /** Refuse every later request carrying `token`, and abort the calls it has in flight. */
+    revoke(token: string): void;
+    dispose(): Promise<void>;
+    private issue;
+    private start;
+    private handle;
+}
+/** The process's one server, which the daemon and the extension host hand to every session they build. */
+declare function sharedMcpServer(): OrdewellMcpServer;
+
+/** The server's name in every runner's MCP configuration, and so in its tool names (`mcp__ordewell__*`). */
+declare const ORDEWELL_MCP_SERVER_NAME = "ordewell";
+interface McpClientConfig {
+    name: typeof ORDEWELL_MCP_SERVER_NAME;
+    url: string;
+    headers: Record<string, string>;
+}
+/**
+ * The one shape every runner adapter renders its own MCP configuration from.
+ * The token travels only in `headers`: the adapter writes it to an owner-only
+ * file or an environment variable, never a prompt or a process argument
+ * (ADR-0022, A4/A5).
+ */
+declare function mcpClientConfig(credential: McpCredential): McpClientConfig;
+/** A runner's MCP configuration on disk, and the way to take it back off. */
+interface OwnerOnlyFile {
+    path: string;
+    /** Delete the file. Idempotent. */
+    remove(): void;
+}
+/**
+ * Write a configuration that carries a token where only the user can read it,
+ * for a runner that takes its MCP servers from a file (ADR-0022, A5). The
+ * directory is private too, so the name cannot be raced before the mode lands.
+ */
+declare function ownerOnlyConfigFile(fileName: string, contents: string): OwnerOnlyFile;
+
 /**
  * The harness-planner transport contract (ADR-0009).
  *
@@ -1041,6 +1321,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';
@@ -1065,6 +1363,8 @@ interface PlannerStartOptions extends AgentStartCommon {
     systemPrompt: string;
     /** Variant / reasoning effort id from that model's `variants` list. */
     effort?: string;
+    /** The Ordewell MCP server to inject, pre-authorized (ADR-0022). Only for an adapter with {@link AgentAdapter.mcpAttached}. */
+    mcp?: McpClientConfig;
 }
 /**
  * What a runner manifest says the task's mode and effort mean (ADR-0001),
@@ -1085,6 +1385,12 @@ interface TaskStartOptions extends AgentStartCommon {
     /** The task's runner mode id, as the plan names it. */
     mode: string;
     flags: TaskRunnerFlags;
+    /**
+     * The Ordewell MCP server and this attempt's token (ADR-0022). An adapter
+     * that can inject it does, with its tools pre-approved; one that cannot
+     * ignores it, and the task completes by its marker.
+     */
+    mcp?: McpClientConfig;
 }
 /**
  * The explicit start switch. Discriminated so that a read-only planner and a
@@ -1120,6 +1426,12 @@ interface AgentAdapter {
     nativeSessionId(): string | null;
     /** Kill the process and release its resources. Idempotent. */
     dispose(): void;
+    /**
+     * Whether the Ordewell MCP server passed in {@link PlannerStartOptions.mcp}
+     * is connected, as the runner itself reports it (ADR-0022, S4). Absent on an
+     * adapter that cannot inject the server at all.
+     */
+    mcpAttached?(): Promise<boolean>;
 }
 /** What an adapter adds to run a task rather than a planner (ADR-0018). */
 interface TaskModeAgentAdapter extends AgentAdapter {
@@ -1139,6 +1451,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.
@@ -1719,25 +2041,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). */
  | {
@@ -1753,6 +2099,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
@@ -1766,13 +2116,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 —
@@ -1787,6 +2147,17 @@ interface StructuredSessionCapability {
      * when it is no longer open — answered, withdrawn, or never asked.
      */
     answerPermission(id: string, decision: ApprovalDecision): boolean;
+    /**
+     * The runner's `task_complete` calls on this attempt's token (ADR-0022):
+     * completion evidence beside the marker, for `VerdictEngine` to weigh.
+     */
+    onTaskComplete(listener: (report: TaskCompleteArgs) => void): void;
+    /**
+     * Answers the runner's `checkpoint` calls (ADR-0022, V5): the call stays
+     * open until the returned promise settles, and its result is the answer.
+     * `signal` aborts when the caller goes away.
+     */
+    onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
 }
 declare function isStructuredSession(session: ITerminalSession): session is ITerminalSession & StructuredSessionCapability;
 
@@ -1827,6 +2198,11 @@ interface ITerminalRunner {
          * which is why a continue refuses one.
          */
         resumeSessionId?: string;
+        /**
+         * Which run of the task this is, from 1. A structured runner binds the
+         * attempt's MCP token to it (ADR-0022, A2).
+         */
+        attempt?: number;
     }): Promise<ITerminalSession>;
     stop(sessionId: string): void;
     stopAll(): void;
@@ -1840,7 +2216,7 @@ interface UserStep {
 }
 /** One deterministic signal gathered while verifying a completed task. */
 interface VerificationCheck {
-    name: 'exit_code' | 'completion_marker' | 'manual';
+    name: 'exit_code' | 'completion_marker' | 'task_complete' | 'manual';
     passed: boolean;
     /** A check that did not apply. Skipped checks don't affect the verdict. */
     skipped: boolean;
@@ -2159,6 +2535,22 @@ 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;
 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. */
@@ -2199,4 +2591,4 @@ interface ValidationContext {
 type ValidationCheck = (ctx: ValidationContext) => ValidationResult;
 declare function warningsText(w: PlanModificationWarnings): string | null;
 
-export { type IsolationRun as $, AbstractRunner as A, type BlockingPrompt as B, CMD_EXE_MAX_COMMAND_LINE as C, DENY_ALL as D, EmbeddedNewlineError as E, type FetchAllProviderModelsOptions as F, HeadlessSession as G, HeadlessRunner as H, type IApproval as I, type IConfig as J, type IPluginStore as K, type ITerminalRunner as L, type ITerminalSession as M, type IWorktreeIsolation as N, type IntegrationDisposal as O, type IsolationAvailability as P, type IsolationHandoff as Q, type IsolationHandoffRepo as R, type IsolationInactiveReason as S, type IsolationLandedTask as T, type IsolationLanding as U, type IsolationMergeBlock as V, type IsolationMergeBlockReason as W, type IsolationMergeResult as X, type IsolationOutcome as Y, type IsolationPruneResult as Z, type IsolationRepo as _, AbstractTerminalSession as a, type TaskModelAssignment as a$, type IsolationTaskRecord as a0, type IsolationTaskRepo as a1, type IsolationTaskStatus as a2, type IsolationView as a3, type LaunchDeps as a4, type LaunchPlan as a5, type LegacyPlanState as a6, LineBuffer as a7, type Message as a8, ModelCatalog as a9, type ResearchLogEntry as aA, type ResearchProgress as aB, type ResearchStep as aC, type ResearchStepOutcome as aD, type ResearchToolType as aE, type ResolveContext as aF, type RunnerId as aG, type RunnerInvocation as aH, type RunnerPluginManifest as aI, RunnerRegistry as aJ, type RunnerSpawnOptions as aK, type RunnerTransport as aL, type RunnerVersionProbe as aM, type StreamEvent as aN, type StreamStepEvent as aO, type StreamThinkingEvent as aP, type StructuredEvent as aQ, type StructuredSessionCapability as aR, type StructuredTurnEnd as aS, type SubagentLogEntry as aT, type SubagentOutcome as aU, type Task as aV, type TaskIsolation as aW, type TaskIsolationState as aX, type TaskMode as aY, type TaskModeAgentAdapter as aZ, TaskModeUnsupportedError as a_, type ModelShortcut as aa, ORCHESTRATOR_SHORTCUTS as ab, type OrchestratorOption as ac, type PlanIsolation as ad, type PlanModificationWarnings as ae, type PlanState as af, type PlanStatus as ag, type PlannerStartOptions as ah, type PlannerUsage as ai, type PluginCloneFn as aj, type PluginEntry as ak, type PluginFeatures as al, type PluginMode as am, type PluginModelDiscovery as an, type PluginRunnerDef as ao, type PreparedLaunch as ap, type PreparedTask as aq, type ProviderCredentialSource as ar, type ProviderModelLists as as, type ProviderModelsResult as at, type PtySize as au, type PtyWrapOptions as av, type QueuedMessage as aw, type QueuedTaskMessage as ax, type RepairEvidence as ay, type RepoGroupLayout as az, type ActiveTaskSession as b, windowsCommandLine as b$, type TaskOutputSummary as b0, type TaskRunnerFlags as b1, type TaskSnapshot as b2, type TaskStartOptions as b3, type TaskStatus as b4, type TaskTransport as b5, type TaskType as b6, type TaskWithParent as b7, type ThinkingBlock as b8, type TreeSnapshot as b9, isGranted as bA, isMeasured as bB, isReservedRunnerName as bC, isRunnerApproval as bD, isRunnerTransport as bE, isStructuredSession as bF, keepExecutionState as bG, knownModelId as bH, migrateLegacyPlan as bI, migratePlanState as bJ, migrateTask as bK, partedPromptUsage as bL, planDirectLaunch as bM, planShellLaunch as bN, plannerContextFill as bO, posixShellQuote as bP, removeTaskFromPlan as bQ, renumberTasks as bR, resolveModelShortcut as bS, resolveProvider as bT, stripAnsi as bU, toApprovalDecision as bV, toOrchestratorOptions as bW, updateTaskInPlan as bX, usageLine as bY, validateModifiedPlan as bZ, warningsText as b_, type UsageLine as ba, type UsageRecord as bb, type UsageTotals as bc, type UserPromptEntry as bd, type UserStep as be, type ValidationCheck as bf, type ValidationContext as bg, type ValidationResult as bh, type Verdict as bi, type VerificationCheck as bj, WINDOWS_MAX_COMMAND_LINE as bk, addPlannerUsage as bl, addTaskToPlan as bm, addUsage as bn, approvalScopes as bo, buildShellInvocation as bp, collectProviderCredentials as bq, createEmptyPlan as br, createTask as bs, emptyWarnings as bt, enabledRunners as bu, fetchAllProviderModels as bv, flattenTasks as bw, flattenTasksWithParents as bx, isAwaitingReason as by, isExecutableResolved as bz, type AgentAdapter as c, wrapWithPty as c0, 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, CommandLineTooLongError as t, type ConversationMessage as u, type DiscoveredMode as v, type DiscoveredModel as w, type DiscoveryCommand as x, ExecutableNotFoundError as y, type HeadlessRunnerDeps as z };
+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 RunnerId as a$, type IsolationPruneResult as a0, type IsolationRemoval as a1, type IsolationRepo as a2, type IsolationRun as a3, type IsolationTaskRecord as a4, type IsolationTaskRef as a5, type IsolationTaskRepo as a6, type IsolationTaskStatus as a7, type IsolationView as a8, type LaunchDeps as a9, type PlannerToolHandler as aA, type PlannerUsage as aB, type PluginCloneFn as aC, type PluginEntry as aD, type PluginFeatures as aE, type PluginMode as aF, type PluginModelDiscovery as aG, type PluginRunnerDef as aH, type PreparedLaunch as aI, type PreparedTask as aJ, type PreservedWork as aK, type ProviderCredentialSource as aL, type ProviderModelLists as aM, type ProviderModelsResult as aN, type PtySize as aO, type PtyWrapOptions as aP, type QueuedMessage as aQ, type QueuedTaskMessage as aR, type RefusedRemoval as aS, type RepairEvidence as aT, type RepoGroupLayout as aU, type ResearchLogEntry as aV, type ResearchProgress as aW, type ResearchStep as aX, type ResearchStepOutcome as aY, type ResearchToolType as aZ, type ResolveContext as a_, type LaunchPlan as aa, type LegacyPlanState as ab, LineBuffer as ac, type ListModelsArgs as ad, type ListRunnersArgs as ae, type McpClientConfig as af, type McpCredential as ag, type McpTool as ah, type McpToolContext as ai, type McpToolReply as aj, type Message as ak, ModelCatalog as al, type ModelShortcut as am, ORCHESTRATOR_SHORTCUTS as an, ORDEWELL_MCP_PATH as ao, ORDEWELL_MCP_SERVER_NAME as ap, type OrchestratorOption as aq, OrdewellMcpServer as ar, type OwnerOnlyFile as as, PLANNER_TOOLS as at, type PlanIsolation as au, type PlanModificationWarnings as av, type PlanState as aw, type PlanStatus as ax, type PlannerStartOptions as ay, type PlannerTokenScope as az, type ActiveTaskSession as b, inheritedOps as b$, type RunnerInvocation as b0, type RunnerPluginManifest as b1, RunnerRegistry as b2, type RunnerSpawnOptions as b3, type RunnerTransport as b4, type RunnerVersionProbe as b5, type StreamEvent as b6, type StreamStepEvent as b7, type StreamThinkingEvent as b8, type StructuredEvent as b9, type TaskWithParent as bA, type ThinkingBlock as bB, type TreeSnapshot as bC, type UsageLine as bD, type UsageRecord as bE, type UsageTotals as bF, type UserPromptEntry as bG, type UserStep as bH, type ValidationCheck as bI, type ValidationContext as bJ, type ValidationResult as bK, type Verdict as bL, type VerificationCheck as bM, WINDOWS_MAX_COMMAND_LINE as bN, addPlannerUsage as bO, addTaskToPlan as bP, addUsage as bQ, approvalScopes as bR, buildShellInvocation as bS, collectProviderCredentials as bT, createEmptyPlan as bU, createTask as bV, emptyWarnings as bW, enabledRunners as bX, fetchAllProviderModels as bY, flattenTasks as bZ, flattenTasksWithParents as b_, type StructuredSessionCapability as ba, type StructuredTurnEnd as bb, type SubagentLogEntry as bc, type SubagentOutcome as bd, type SubmitPlanArgs as be, TASK_COMPLETE_TOOL as bf, TASK_TOOLS as bg, type Task as bh, type TaskCompleteArgs as bi, type TaskIsolation as bj, type TaskIsolationState as bk, type TaskMode as bl, type TaskModeAgentAdapter as bm, TaskModeUnsupportedError as bn, type TaskModelAssignment as bo, type TaskOutputArgs as bp, type TaskOutputSummary as bq, type TaskQueryArgs as br, type TaskRunnerFlags as bs, type TaskSnapshot as bt, type TaskStartOptions as bu, type TaskStatus as bv, type TaskTokenScope as bw, type TaskToolHandler as bx, type TaskTransport as by, type TaskType as bz, type AgentAdapter as c, isAwaitingReason as c0, isExecutableResolved as c1, isGranted as c2, isMeasured as c3, isReservedRunnerName as c4, isRunnerApproval as c5, isRunnerTransport as c6, isStructuredSession as c7, keepExecutionState as c8, knownModelId as c9, mcpClientConfig as ca, migrateLegacyPlan as cb, migratePlanState as cc, migrateTask as cd, opsFlag as ce, ownerOnlyConfigFile as cf, partedPromptUsage as cg, planDirectLaunch as ch, planShellLaunch as ci, plannerContextFill as cj, posixShellQuote as ck, removeTaskFromPlan as cl, renumberTasks as cm, resolveModelShortcut as cn, resolveProvider as co, sharedMcpServer as cp, stripAnsi as cq, toApprovalDecision as cr, toOrchestratorOptions as cs, updateTaskInPlan as ct, usageLine as cu, validateModifiedPlan as cv, warningsText as cw, windowsCommandLine as cx, wrapWithPty as cy, 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 };