@ordewell/core 0.10.1 → 0.10.3

package/dist/{plan-utils-B6yJdpgi.d.ts → plan-utils-oC8bO4pN.d.ts}

@@ -1,6 +1,17 @@
-import { $ as RunnerId, c as DiscoveredModel, ac as Task, a9 as SkillsService, a4 as SkillInfo, U as RepoGroupLayout, aj as TaskSkillSnapshot, ai as TaskSkillNotice, aa as SubagentOutcome, ao as UsageRecord, ak as TaskSnapshot, a as AwaitingReason, I as IWorktreeIsolation, v as IsolationRun, j as IsolationHandoff, H as PlanIsolation, w as IsolationTaskRecord, af as TaskIsolation, F as IsolationView, r as IsolationOutcome, T as RepairEvidence, am as TreeSnapshot, ad as TaskDiffRead, ae as TaskDiffResult, q as IsolationMergeResult, aq as Verdict, _ as RunSettings, L as LegacyPlanState, C as ConversationMessage, a6 as SkillLoadNotice, P as PendingPlanTurn, A as AttemptUsage, M as ModelUsage, ap as UsageTotals, N as PlanUsage, e as ExecutionRecord, X as ResearchStep, J as PlanState, ab as SupervisorLevel, Y as ResearchStepOutcome, V as ResearchLogEntry, O as PlannerUsage, ag as TaskIsolationState, an as UsageLine } from './Task-CxwnCJLi.js';
-import { R as RunnerModeInfo } from './ModeResolver-u5ZhRC8x.js';
-import { B as IRunnerSession, aB as TaskMessageFrom, ah as RunnerCommand, am as RunnerMcpServer, au as StructuredTurnEnd, j as ApprovalDecision, at as StructuredEvent, y as IConfig, z as IRunner, ap as RunnerRegistry, aa as QueuedTaskMessage, k as ApprovalKind, q as ApprovalSource } from './IRunner-C7_SSpzG.js';
+import { af as Task, a2 as RunnerId, an as TaskSnapshot, b as AwaitingReason, ar as UsageRecord, d as DiscoveredModel, ac as SkillsService, a7 as SkillInfo, X as RepoGroupLayout, I as IWorktreeIsolation, w as IsolationRun, k as IsolationHandoff, J as PlanIsolation, x as IsolationTaskRecord, ai as TaskIsolation, H as IsolationView, R as PrepareIntent, U as PreviousWork, s as IsolationOutcome, W as RepairEvidence, ap as TreeSnapshot, ag as TaskDiffRead, ah as TaskDiffResult, r as IsolationMergeResult, at as Verdict, am as TaskSkillSnapshot, al as TaskSkillNotice, ad as SubagentOutcome, L as LegacyPlanState, C as ConversationMessage, a9 as SkillLoadNotice, P as PendingPlanTurn, a as AttemptUsage, M as ModelUsage, as as UsageTotals, O as PlanUsage, f as ExecutionRecord, _ as ResearchStep, a1 as RunSettings, K as PlanState, ae as SupervisorLevel, $ as ResearchStepOutcome, Y as ResearchLogEntry, Q as PlannerUsage, aj as TaskIsolationState, aq as UsageLine } from './Task-CRVIqSfy.js';
+import { R as RunnerModeInfo } from './ModeResolver-BOU90Nn-.js';
+import { B as IRunnerSession, y as IConfig, aC as TaskMessageFrom, ai as RunnerCommand, an as RunnerMcpServer, av as StructuredTurnEnd, j as ApprovalDecision, au as StructuredEvent, ab as QueuedTaskMessage, k as ApprovalKind, q as ApprovalSource, z as IRunner, aq as RunnerRegistry } from './IRunner-QBdYcatb.js';
+
+type NotificationAction = {
+    label: string;
+    value: string;
+};
+interface INotification {
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    confirm(msg: string, options: string[]): Promise<string | undefined>;
+}
 
 interface LiveTailOptions {
     maxLines: number;
@@ -33,6 +44,126 @@ interface TaskOutputSource {
     liveTail(taskId: string, opts: LiveTailOptions): LiveTail | null;
 }
 
+/**
+ * The deep module owning all plan-shaped state. Holds `planTasks` (the ordered
+ * tree the user edits), the flattened `allTasks` view and the `taskMap` index.
+ * The orchestrator calls `markCompleted`/`markFailed`/`markInProgress`/`retry`
+ * to update task status — it never mutates task state directly.
+ *
+ * Completion and failure are read from `task.status` and nothing else, so
+ * `isCompleted`, `completedCount`, `isAllComplete` and the scheduler's
+ * dependency checks cannot disagree. The store owns its task objects: `load`
+ * copies what it is given, the getters hand out readonly views, and
+ * `snapshot` is the copy a caller may keep or write to disk.
+ *
+ * `rebuild` is the internal seam that keeps the flat views in sync with the
+ * tree.
+ *
+ * `planRunners` lives here because it's part of the plan's identity (the runner
+ * set, carried on the plan). `validateAssignedRunners` is pure store logic.
+ */
+declare class PlanStore {
+    private _planTasks;
+    private _allTasks;
+    private _taskMap;
+    /** Task id → the top-level task it hangs under, itself for a top-level task. */
+    private _rootMap;
+    private _planRunners;
+    private _onMutate;
+    private _onTree;
+    private _executionLog;
+    /** Hook called after every structural mutation (add/remove/update/resetForRun). */
+    set onMutate(cb: (() => void) | null);
+    /**
+     * Called with every task id, subtasks included, each time the tree is
+     * rebuilt — on every route a task enters or leaves the plan, loads and
+     * reconciled edits included, which `onMutate` does not hear.
+     */
+    set onTree(cb: ((ids: ReadonlySet<string>) => void) | null);
+    get planTasks(): ReadonlyArray<Readonly<Task>>;
+    get allTasks(): ReadonlyArray<Readonly<Task>>;
+    get planRunners(): RunnerId[];
+    get completedCount(): number;
+    get failedCount(): number;
+    isAllComplete(): boolean;
+    isAnyFailed(): boolean;
+    isCompleted(id: string): boolean;
+    isSkipped(id: string): boolean;
+    /** Nothing is left to do: every task completed or was skipped. */
+    isFinished(): boolean;
+    isFailed(id: string): boolean;
+    get(taskId: string): Readonly<Task> | undefined;
+    /**
+     * Whether a task runs as an ops task (ADR-0020). Only a top-level AI task
+     * can be one; a subtask runs with the top-level task it hangs under.
+     */
+    isOps(taskId: string): boolean;
+    /** A copy of the task tree, detached from the store: later status changes do not reach it. */
+    snapshot(): Task[];
+    getExecutionLog(): ReadonlyArray<TaskSnapshot>;
+    appendToLog(snapshot: TaskSnapshot): void;
+    /**
+     * Drop a task's archived snapshot. Un-marking a completion has to erase the
+     * "finished" record too — dependent tasks are prompted from the log, so a
+     * left-behind snapshot would keep feeding them a result that no longer exists.
+     */
+    removeFromLog(taskId: string): void;
+    clearLog(): void;
+    private notifyMutate;
+    private countStatus;
+    load(tasks: ReadonlyArray<Readonly<Task>>, runners: readonly RunnerId[]): void;
+    add(partial: Partial<Task>): Task;
+    remove(taskId: string): void;
+    update(taskId: string, changes: Partial<Task>): Task | undefined;
+    /**
+     * Run preparation as one named op: flip every AI task to 'approved'. By
+     * default completed tasks keep their status so a reloaded half-finished plan
+     * resumes the remainder instead of re-running work that already succeeded,
+     * and skipped ones stay skipped: a new run is not a retry of them.
+     * `preserveCompleted: false` is for a freshly committed plan, where
+     * everything starts over. `keepScheduledResumes` leaves a task waiting on
+     * its runner's usage-limit reset waiting: an edit adopted between runs is
+     * not the user starting over.
+     */
+    resetForRun(opts?: {
+        preserveCompleted?: boolean;
+        keepScheduledResumes?: boolean;
+    }): void;
+    markCompleted(id: string): void;
+    markFailed(id: string): void;
+    markSkipped(id: string, reason?: string): void;
+    markInProgress(id: string): void;
+    markAwaitingUser(id: string, reason?: AwaitingReason): void;
+    /** When a task paused on a usage limit resumes on its own; undefined leaves it to a manual retry. */
+    setTaskResumeAt(id: string, resumeAt: string | undefined): void;
+    markPending(id: string): void;
+    retry(id: string): void;
+    /** Kept on the task: it was force-started past its merge gate, before these ancestors' work was merged (ADR-0020). */
+    setForcedPastGate(id: string, dependencies: string[]): void;
+    /** A reason outlives nothing: any status but `awaiting_user` drops it, and the resume time with it; any status drops a skip's reason. */
+    private setStatus;
+    blockDependents(id: string): void;
+    unblockDependents(id: string): void;
+    setTaskVerdict(id: string, verdict: Task['verdict']): void;
+    setTaskOutputSummary(id: string, summary: Task['outputSummary']): void;
+    setTaskRunnerSessionId(id: string, runnerSessionId: string | undefined): void;
+    clearCarriedFrom(id: string): void;
+    startAttemptUsage(id: string, attempt: number, runner: string, startedAt: string): void;
+    recordAttemptUsage(id: string, attempt: number, record: UsageRecord, now: string): void;
+    endAttemptUsage(id: string, attempt: number, now: string): void;
+    setTaskAttemptSkills(id: string, skills: Task['attemptSkills']): void;
+    /**
+     * Widen the plan's runner set. Retargeting a task onto a runner the plan has
+     * not used before has to land here as well as on the plan state, or
+     * {@link resolveTaskRunner} reads the new runner as foreign and spawns the
+     * plan's first one instead.
+     */
+    admitRunner(runner: RunnerId): void;
+    resolveTaskRunner(task: Readonly<Task>): RunnerId;
+    private rebuild;
+    private validateAssignedRunners;
+}
+
 /**
  * The catalog a model/task-mode edit is checked against — the same discovered
  * models and manifest modes the planner was shown in the per-turn catalog
@@ -100,6 +231,8 @@ interface ApplyTaskOpsResult {
     errors: string[];
     /** Human-readable summary of what changed, for the chat transcript. */
     summary: string[];
+    /** On ok, the id of the task each batch handle names. */
+    handles?: ReadonlyMap<string, string>;
 }
 /**
  * Pre-flight check for a merge: would collapsing the selected tasks into one
@@ -200,450 +333,119 @@ interface PlannerModes {
     taskSkills?: SkillLookup;
 }
 
-/**
- * One entry of a structured task's log (ADR-0018, P1): what a runner did,
- * normalized and serializable, streamed live as `task_log` and appended to
- * the attempt's `.jsonl` file. The live view and the reload fold the same
- * events through `reduceTaskLog`, so the two cannot disagree.
- *
- * Readers skip a type they do not know, which is how later events join
- * without a format version.
- */
-type TaskLogEvent = 
-/**
- * The task skills this attempt's prompt carried, as read at its spawn
- * (ADR-0024): first in its log. The file keeps their bodies; a surface is
- * sent notices ({@link taskLogForSurface}).
- */
-{
-    type: 'task_skills';
-    skills: TaskSkillSnapshot[] | TaskSkillNotice[];
+type IsolationNoticeLevel = 'info' | 'warn' | 'error';
+/** How an attempt that may run in a worktree gets one: fresh, the kept one for a repair, or restoring the previous attempt's work. */
+type AttemptIntent = 'fresh' | 'repair' | PrepareIntent;
+interface AttemptWorkspace {
+    cwd: string;
+    worktree: boolean;
+    /** Set for a `restore` in a worktree; absent in the checkout, where the previous attempt's edits remain. */
+    previousWork?: PreviousWork;
 }
 /**
- * A turn began by delivering `message`; `messageId` names it when it had been
- * queued, `forced` when it was force sent. `from` on this and the other
- * message events marks one Ordewell sent rather than the user.
+ * What the controller reports. It never schedules or emits on its own: the
+ * orchestrator turns these into observer events and decides what runs next.
  */
- | {
-    type: 'turn_start';
-    message: string;
-    messageId?: string;
-    forced?: boolean;
-    from?: TaskMessageFrom;
+interface IsolationRunListener {
+    /**
+     * The run record changed and should be persisted with the plan. `detached`
+     * is set instead when the record that changed is no longer the plan's own —
+     * a release that outlived the plan load that replaced its run — and belongs
+     * to the session that was left.
+     */
+    changed(detached?: IsolationRun): void;
+    /** A run did not start: `repos` of the group have tracked changes. */
+    blocked(repos: string[]): void;
+    /** An isolated run closed and handed its integration branches over. */
+    handoff(handoff: IsolationHandoff): void;
+    /** Already said through the notifications; also for a surface that shows no toasts. */
+    notice(level: IsolationNoticeLevel, message: string): void;
+}
+interface IsolationRunControllerDeps {
+    isolation: IWorktreeIsolation;
+    config: IConfig;
+    notifications: INotification;
+    workspaceRoot: () => string;
+    listener: IsolationRunListener;
+    /**
+     * The tasks no clean-up of the whole run may take a worktree from: an
+     * attempt is running them, or the plan has them in progress or waiting on
+     * the user mid-attempt.
+     */
+    liveTasks: () => ReadonlySet<string>;
 }
 /**
- * A turn began by running the runner's own command `/name args` (#66): the
- * `turn_start` of a command turn. `messageId` names it when it had been queued.
+ * The lifecycle of a plan's isolation run (ADR-0013, ADR-0014, ADR-0020),
+ * between the scheduler and the git layer: deciding, at a run's first change
+ * task, whether it executes in worktrees, a blocked run and how it goes on,
+ * each attempt's working directory, releasing worktrees, which landed work the
+ * user has merged, the tree check of an ops task, the handoff when the run
+ * closes, and what the user does with it afterwards. The record it keeps
+ * outlives one run — a resumed plan continues it.
  */
- | {
-    type: 'command';
-    name: string;
-    args?: string;
-    messageId?: string;
-}
-/** What the running command printed, for one that runs without the model. */
- | {
-    type: 'command_output';
-    text: string;
-}
-/** The runner compacted its own context, asked to or on its own. */
- | {
-    type: 'compaction';
-    trigger: 'manual' | 'auto';
-    preTokens?: number;
-    postTokens?: number;
-}
-/** What the runner loaded from the user's and the project's setup, as its process started. */
- | {
-    type: 'runner_loaded';
-    commands: RunnerCommand[];
-    mcpServers: RunnerMcpServer[];
-} | {
-    type: 'turn_end';
-    reason: StructuredTurnEnd;
-} | {
-    type: 'text_delta';
-    text: string;
-}
-/** A complete run of the agent's reply, authoritative over the deltas streamed for it. */
- | {
-    type: 'text';
-    text: string;
-} | {
-    type: 'thinking_delta';
-    text: string;
-    subagentId?: string;
-} | {
-    type: 'thinking';
-    text: string;
-    subagentId?: string;
-}
-/** `args` is the call's arguments as JSON, exactly as the runner announced them. */
- | {
-    type: 'tool_call';
-    id: string;
-    name: string;
-    args: string;
-    subagentId?: string;
-}
-/** `omittedLines` is set when {@link trimToolOutput} cut the middle of `output`. */
- | {
-    type: 'tool_result';
-    id: string;
-    output: string;
-    success: boolean;
-    omittedLines?: number;
-    subagentId?: string;
-} | {
-    type: 'subagent_started';
-    subagentId: string;
-    brief: string;
-    model?: string;
-} | {
-    type: 'subagent_finished';
-    subagentId: string;
-    outcome: SubagentOutcome;
-    digest: string;
-} | {
-    type: 'usage';
-    record: UsageRecord;
-}
-/**
- * Waiting in Ordewell's queue — again, for a message the runner was handed
- * and let go of (ADR-0023, D4). `forced` moves it ahead of the rest (F2).
- */
- | {
-    type: 'message_queued';
-    messageId: string;
-    text: string;
-    forced?: boolean;
-    from?: TaskMessageFrom;
-} | {
-    type: 'message_removed';
-    messageId: string;
-} | {
-    type: 'message_undelivered';
-    messageId: string;
-    text: string;
-    from?: TaskMessageFrom;
-}
-/** The runner accepted a queued message into its running turn; it can no longer be taken back. */
- | {
-    type: 'message_handed_over';
-    messageId: string;
-}
-/**
- * The model read a message inside its running turn (ADR-0023, Q2), logged
- * where it read it. A message that opened a turn is that turn's `turn_start`.
- */
- | {
-    type: 'message_delivered';
-    messageId: string;
-    text: string;
-    from?: TaskMessageFrom;
-}
-/** The agent's own words for a failed turn. */
- | {
-    type: 'error';
-    message: string;
-}
-/**
- * The runner asked to use a tool its mode does not cover (ADR-0018, A1).
- * `approvalId` is what the answer is given under; `args` is the call's
- * arguments as JSON; `allowForTask` says the runner offered its own
- * session-scoped grant. `decided` is set when the request was never left
- * open — an Ordewell tool or an auto-approving mode — so a surface does not
- * offer to answer what is already answered (it is still followed by the
- * matching `approval_decided`, which a reader may rely on).
- */
- | {
-    type: 'approval_requested';
-    approvalId: string;
-    tool: string;
-    args: string;
-    allowForTask: boolean;
-    toolCallId?: string;
-    decided?: ApprovalDecision['decision'];
-} | {
-    type: 'approval_decided';
-    approvalId: string;
-    decision: ApprovalDecision['decision'];
-    note?: string;
-}
-/** The request went unanswered: the runner withdrew it, or its process ended. */
- | {
-    type: 'approval_withdrawn';
-    approvalId: string;
-}
-/**
- * The runner's process ended. A call it had not reported back on is not
- * running any more: a task's runner is ended the moment its `task_complete`
- * lands, often before it reports that call's result.
- */
- | {
-    type: 'runner_ended';
-};
-/**
- * Keep a tool result's head and tail. A build log or a whole file read can
- * run to megabytes, and every attempt's file keeps it for good; the ends are
- * where a reader looks — the command's start, and how it finished.
- */
-declare function trimToolOutput(output: string): {
-    output: string;
-    omittedLines?: number;
-};
-/**
- * The log entry for one structured event, or null for what the log does not
- * keep: background-agent launches, which the subagent's own events already show.
- */
-declare function toTaskLogEvent(event: StructuredEvent): TaskLogEvent | null;
-/** A log as a surface is sent it, live or read back: everything but the skills' bodies. */
-declare function taskLogForSurface(events: readonly TaskLogEvent[]): TaskLogEvent[];
-/**
- * Merge runs of deltas into one event each. Deltas arrive a few characters at
- * a time; merged, a batch is one message on the wire and one line on disk,
- * and the view folds to the same blocks either way.
- */
-declare function coalesceTaskLog(events: readonly TaskLogEvent[]): TaskLogEvent[];
-/**
- * What an attempt did to the world, for the retry of a task whose effects
- * outlive it (ADR-0020): one line per tool call and how it ended.
- */
-declare function digestTaskLog(events: readonly TaskLogEvent[], maxCalls: number): string;
-
-type NotificationAction = {
-    label: string;
-    value: string;
-};
-interface INotification {
-    info(msg: string): void;
-    warn(msg: string): void;
-    error(msg: string): void;
-    confirm(msg: string, options: string[]): Promise<string | undefined>;
-}
-
-/**
- * The deep module owning all plan-shaped state. Holds `planTasks` (the ordered
- * tree the user edits), the flattened `allTasks` view and the `taskMap` index.
- * The orchestrator calls `markCompleted`/`markFailed`/`markInProgress`/`retry`
- * to update task status — it never mutates task state directly.
- *
- * Completion and failure are read from `task.status` and nothing else, so
- * `isCompleted`, `completedCount`, `isAllComplete` and the scheduler's
- * dependency checks cannot disagree. The store owns its task objects: `load`
- * copies what it is given, the getters hand out readonly views, and
- * `snapshot` is the copy a caller may keep or write to disk.
- *
- * `rebuild` is the internal seam that keeps the flat views in sync with the
- * tree.
- *
- * `planRunners` lives here because it's part of the plan's identity (the runner
- * set, carried on the plan). `validateAssignedRunners` is pure store logic.
- */
-declare class PlanStore {
-    private _planTasks;
-    private _allTasks;
-    private _taskMap;
-    /** Task id → the top-level task it hangs under, itself for a top-level task. */
-    private _rootMap;
-    private _planRunners;
-    private _onMutate;
-    private _executionLog;
-    /** Hook called after every structural mutation (add/remove/update/resetForRun). */
-    set onMutate(cb: (() => void) | null);
-    get planTasks(): ReadonlyArray<Readonly<Task>>;
-    get allTasks(): ReadonlyArray<Readonly<Task>>;
-    get planRunners(): RunnerId[];
-    get completedCount(): number;
-    get failedCount(): number;
-    isAllComplete(): boolean;
-    isAnyFailed(): boolean;
-    isCompleted(id: string): boolean;
-    isSkipped(id: string): boolean;
-    /** Nothing is left to do: every task completed or was skipped. */
-    isFinished(): boolean;
-    isFailed(id: string): boolean;
-    get(taskId: string): Readonly<Task> | undefined;
+declare class IsolationRunController {
+    private readonly isolation;
+    private readonly config;
+    private readonly notifications;
+    private readonly workspaceRoot;
+    private readonly listener;
+    private readonly liveTasks;
+    private run;
+    /** Copied paths already reported for the current run: every task gets the same copies. */
+    private reportedCopies;
+    private reportedSetupFailures;
     /**
-     * Whether a task runs as an ops task (ADR-0020). Only a top-level AI task
-     * can be one; a subtask runs with the top-level task it hangs under.
+     * How the open run executes; null while no run is open, `undecided` until
+     * its first change task asks. A run is one Execute-Plan or one manual task
+     * run, from its start until it settles or is stopped.
      */
-    isOps(taskId: string): boolean;
-    /** A copy of the task tree, detached from the store: later status changes do not reach it. */
-    snapshot(): Task[];
-    getExecutionLog(): ReadonlyArray<TaskSnapshot>;
-    appendToLog(snapshot: TaskSnapshot): void;
+    private mode;
+    /** Resolver task id → the conflicted task it resolves; see {@link linkResolver}. */
+    private resolvers;
+    private opening;
+    /** Bumped by an interrupt, so an activation in flight across it does not open the run it ended. */
+    private activations;
+    /** The start a dirty tree turned away, handed back once the user chooses how to go on. */
+    private blockedStart;
+    /** The dirty repos behind {@link blockedStart}, for the stash notice. */
+    private blockedRepos;
+    constructor(deps: IsolationRunControllerDeps);
+    /** The plan's run record, open or not; null when the plan has not isolated. */
+    get current(): IsolationRun | null;
+    get isOpen(): boolean;
+    /** The open run has decided whether it isolates. */
+    get decided(): boolean;
+    /** The open run executes in worktrees. */
+    get isolating(): boolean;
+    /** A run is waiting on the user to stash or to go on without isolation. */
+    get blocked(): boolean;
+    /** What the plan persists of isolated execution; null when no run ever isolated. */
+    get planIsolation(): PlanIsolation | null;
+    /** The one guard of every action on the run: a plan that never isolated is a request refused, not a fault. */
+    requireRun(): IsolationRun;
+    /** A task's record in the open run, only while that run isolates. */
+    openRecord(taskId: string): IsolationTaskRecord | undefined;
+    /** Where a task's isolated work stands; null when the plan has no isolation run to speak of. */
+    taskIsolation(taskId: string): TaskIsolation | null;
+    view(): IsolationView | null;
     /**
-     * Drop a task's archived snapshot. Un-marking a completion has to erase the
-     * "finished" record too — dependent tasks are prompted from the log, so a
-     * left-behind snapshot would keep feeding them a result that no longer exists.
+     * Take over a plan's persisted isolation, or none for a plan that has not
+     * isolated yet. Whatever a crashed process left behind for the run — a
+     * worktree still marked active, a directory no record owns — is pruned,
+     * while kept, failed and conflicted worktrees stay for the user.
+     *
+     * Deliberately not reported as a change: adopting is not a change to
+     * persist, and a host that adopts without persisting (VS Code's restore)
+     * would otherwise write a new session file on every reload.
      */
-    removeFromLog(taskId: string): void;
-    clearLog(): void;
-    private notifyMutate;
-    private countStatus;
-    load(tasks: ReadonlyArray<Readonly<Task>>, runners: readonly RunnerId[]): void;
-    add(partial: Partial<Task>): Task;
-    remove(taskId: string): void;
-    update(taskId: string, changes: Partial<Task>): Task | undefined;
+    adopt(state: PlanIsolation | null): Promise<void>;
+    /** Open a run if none is, leaving whether it isolates to its first change task. */
+    open(): void;
     /**
-     * Run preparation as one named op: flip every AI task to 'approved'. By
-     * default completed tasks keep their status so a reloaded half-finished plan
-     * resumes the remainder instead of re-running work that already succeeded,
-     * and skipped ones stay skipped: a new run is not a retry of them.
-     * `preserveCompleted: false` is for a freshly committed plan, where
-     * everything starts over. `keepScheduledResumes` leaves a task waiting on
-     * its runner's usage-limit reset waiting: an edit adopted between runs is
-     * not the user starting over.
-     */
-    resetForRun(opts?: {
-        preserveCompleted?: boolean;
-        keepScheduledResumes?: boolean;
-    }): void;
-    markCompleted(id: string): void;
-    markFailed(id: string): void;
-    markSkipped(id: string, reason?: string): void;
-    markInProgress(id: string): void;
-    markAwaitingUser(id: string, reason?: AwaitingReason): void;
-    /** When a task paused on a usage limit resumes on its own; undefined leaves it to a manual retry. */
-    setTaskResumeAt(id: string, resumeAt: string | undefined): void;
-    markPending(id: string): void;
-    retry(id: string): void;
-    /** Kept on the task: it was force-started past its merge gate, before these dependencies' work was merged (ADR-0020). */
-    setForcedPastGate(id: string, dependencies: string[]): void;
-    /** A reason outlives nothing: any status but `awaiting_user` drops it, and the resume time with it; any status drops a skip's reason. */
-    private setStatus;
-    blockDependents(id: string): void;
-    unblockDependents(id: string): void;
-    setTaskVerdict(id: string, verdict: Task['verdict']): void;
-    setTaskOutputSummary(id: string, summary: Task['outputSummary']): void;
-    setTaskRunnerSessionId(id: string, runnerSessionId: string | undefined): void;
-    startAttemptUsage(id: string, attempt: number, runner: string, startedAt: string): void;
-    recordAttemptUsage(id: string, attempt: number, record: UsageRecord, now: string): void;
-    endAttemptUsage(id: string, attempt: number, now: string): void;
-    setTaskAttemptSkills(id: string, skills: Task['attemptSkills']): void;
-    /**
-     * Widen the plan's runner set. Retargeting a task onto a runner the plan has
-     * not used before has to land here as well as on the plan state, or
-     * {@link resolveTaskRunner} reads the new runner as foreign and spawns the
-     * plan's first one instead.
-     */
-    admitRunner(runner: RunnerId): void;
-    resolveTaskRunner(task: Readonly<Task>): RunnerId;
-    private rebuild;
-    private validateAssignedRunners;
-}
-
-type IsolationNoticeLevel = 'info' | 'warn' | 'error';
-interface AttemptWorkspace {
-    cwd: string;
-    worktree: boolean;
-    continuationMessage?: string;
-}
-/**
- * What the controller reports. It never schedules or emits on its own: the
- * orchestrator turns these into observer events and decides what runs next.
- */
-interface IsolationRunListener {
-    /**
-     * The run record changed and should be persisted with the plan. `detached`
-     * is set instead when the record that changed is no longer the plan's own —
-     * a release that outlived the plan load that replaced its run — and belongs
-     * to the session that was left.
-     */
-    changed(detached?: IsolationRun): void;
-    /** A run did not start: `repos` of the group have tracked changes. */
-    blocked(repos: string[]): void;
-    /** An isolated run closed and handed its integration branches over. */
-    handoff(handoff: IsolationHandoff): void;
-    /** Already said through the notifications; also for a surface that shows no toasts. */
-    notice(level: IsolationNoticeLevel, message: string): void;
-}
-interface IsolationRunControllerDeps {
-    isolation: IWorktreeIsolation;
-    config: IConfig;
-    notifications: INotification;
-    workspaceRoot: () => string;
-    listener: IsolationRunListener;
-    /**
-     * The tasks no clean-up of the whole run may take a worktree from: an
-     * attempt is running them, or the plan has them in progress or waiting on
-     * the user mid-attempt.
-     */
-    liveTasks: () => ReadonlySet<string>;
-}
-/**
- * The lifecycle of a plan's isolation run (ADR-0013, ADR-0014, ADR-0020),
- * between the scheduler and the git layer: deciding, at a run's first change
- * task, whether it executes in worktrees, a blocked run and how it goes on,
- * each attempt's working directory, releasing worktrees, which landed work the
- * user has merged, the tree check of an ops task, the handoff when the run
- * closes, and what the user does with it afterwards. The record it keeps
- * outlives one run — a resumed plan continues it.
- */
-declare class IsolationRunController {
-    private readonly isolation;
-    private readonly config;
-    private readonly notifications;
-    private readonly workspaceRoot;
-    private readonly listener;
-    private readonly liveTasks;
-    private run;
-    /** Copied paths already reported for the current run: every task gets the same copies. */
-    private reportedCopies;
-    private reportedSetupFailures;
-    /**
-     * How the open run executes; null while no run is open, `undecided` until
-     * its first change task asks. A run is one Execute-Plan or one manual task
-     * run, from its start until it settles or is stopped.
-     */
-    private mode;
-    /** Resolver task id → the conflicted task it resolves; see {@link linkResolver}. */
-    private resolvers;
-    private opening;
-    /** Bumped by an interrupt, so an activation in flight across it does not open the run it ended. */
-    private activations;
-    /** The start a dirty tree turned away, handed back once the user chooses how to go on. */
-    private blockedStart;
-    /** The dirty repos behind {@link blockedStart}, for the stash notice. */
-    private blockedRepos;
-    constructor(deps: IsolationRunControllerDeps);
-    /** The plan's run record, open or not; null when the plan has not isolated. */
-    get current(): IsolationRun | null;
-    get isOpen(): boolean;
-    /** The open run has decided whether it isolates. */
-    get decided(): boolean;
-    /** The open run executes in worktrees. */
-    get isolating(): boolean;
-    /** A run is waiting on the user to stash or to go on without isolation. */
-    get blocked(): boolean;
-    /** What the plan persists of isolated execution; null when no run ever isolated. */
-    get planIsolation(): PlanIsolation | null;
-    /** The one guard of every action on the run: a plan that never isolated is a request refused, not a fault. */
-    requireRun(): IsolationRun;
-    /** A task's record in the open run, only while that run isolates. */
-    openRecord(taskId: string): IsolationTaskRecord | undefined;
-    /** Where a task's isolated work stands; null when the plan has no isolation run to speak of. */
-    taskIsolation(taskId: string): TaskIsolation | null;
-    view(): IsolationView | null;
-    /**
-     * Take over a plan's persisted isolation, or none for a plan that has not
-     * isolated yet. Whatever a crashed process left behind for the run — a
-     * worktree still marked active, a directory no record owns — is pruned,
-     * while kept, failed and conflicted worktrees stay for the user.
-     *
-     * Deliberately not reported as a change: adopting is not a change to
-     * persist, and a host that adopts without persisting (VS Code's restore)
-     * would otherwise write a new session file on every reload.
-     */
-    adopt(state: PlanIsolation | null): Promise<void>;
-    /** Open a run if none is, leaving whether it isolates to its first change task. */
-    open(): void;
-    /**
-     * Decide once per run, as its first change task starts, whether it executes
-     * in worktrees (ADR-0020): an ops task needs none, so a run of only ops
-     * tasks never asks. `resume` is what a dirty tree parks until the user
-     * chooses how to go on. Resolves false while the run waits on that choice.
+     * Decide once per run, as its first change task starts, whether it executes
+     * in worktrees (ADR-0020): an ops task needs none, so a run of only ops
+     * tasks never asks. `resume` is what a dirty tree parks until the user
+     * chooses how to go on. Resolves false while the run waits on that choice.
      */
     decide(resume: () => Promise<void>): Promise<boolean>;
     /**
@@ -680,7 +482,7 @@ declare class IsolationRunController {
      * the attempt is committed as running, so a spawn abandoned or failed after
      * this settles is not misreported as a change that stuck.
      */
-    attemptCwd(task: Task, intent: 'fresh' | 'repair' | 'continuation'): Promise<AttemptWorkspace>;
+    attemptCwd(task: Task, intent: AttemptIntent): Promise<AttemptWorkspace>;
     /** The workspace root, for an attempt that runs outside any worktree. */
     workspaceCwd(task: Task): Promise<{
         cwd: string;
@@ -944,729 +746,278 @@ interface WorkspaceEnv {
     trackedEnvFile: string | null;
 }
 
-/** What ran an automatic Merge all: a task reaching its merge gate, or the run settling with landed work unmerged. */
-type AutoMergeTrigger = {
-    kind: 'gate';
-    taskId: string;
-} | {
-    kind: 'run_end';
-};
 /**
- * Who opened a run (ADR-0029): a call the user made, or one made for them; a
- * call of the supervisor's own; or a usage-limit reset resuming what it paused.
- * Only the user's starts a run's supervision afresh.
+ * One entry of a structured task's log (ADR-0018, P1): what a runner did,
+ * normalized and serializable, streamed live as `task_log` and appended to
+ * the attempt's `.jsonl` file. The live view and the reload fold the same
+ * events through `reduceTaskLog`, so the two cannot disagree.
+ *
+ * Readers skip a type they do not know, which is how later events join
+ * without a format version.
  */
-type RunOrigin = 'user' | 'supervisor' | 'limit-reset';
-/** What the scheduler reads of the open run's settings, at each decision it makes from them. */
-type SchedulerRunSettings = Pick<RunSettings, 'mergeAtGatesAutomatically'>;
+type TaskLogEvent = 
 /**
- * The one notification channel out of the orchestrator. Everything that used
- * to travel over a separate callback (onRefresh) is an observer event; the
- * Session subscribes once and turns these into SessionMessages.
+ * The task skills this attempt's prompt carried, as read at its spawn
+ * (ADR-0024): first in its log. The file keeps their bodies; a surface is
+ * sent notices ({@link taskLogForSurface}).
  */
-interface OrchestratorObserver {
-    /** Any task-shaped state changed (store mutation, checkpoint, retry, …). */
-    onTaskChanged?(): void;
-    /**
-     * A run reached an outcome that stands until the user acts — completed,
-     * failed, or awaiting the user — on its own, not as the answer to a call.
-     * Emitted before the `onTaskChanged` that announces it, so a listener can
-     * save the outcome before any surface is told.
-     */
-    onTaskSettled?(data: {
-        taskId: string;
-    }): void;
-    onRunStarted?(data: {
-        origin: RunOrigin;
-    }): void;
-    /** An automatic Merge all settled, at a gate or at the run's end; failures are attention events for a supervisor. */
-    onAutoMerge?(data: {
-        trigger: AutoMergeTrigger;
-        result: IsolationMergeResult;
-    }): void;
-    onTick?(): void;
-    onUsageChanged?(): void;
-    onExecutionComplete?(): void;
-    /**
-     * A task paused on its runner's usage limit, or its resume changed:
-     * `resumeAt` is when it resumes on its own (ISO time), null when it waits
-     * for a manual retry — the reset could not be read, the resume was
-     * cancelled, or the resumed attempt hit the limit again at once.
-     * `cancelled` marks the resume being cancelled, which is no new pause.
-     */
-    onUsageLimitWait?(data: {
-        taskId: string;
-        runner: string;
-        resumeAt: string | null;
-        cancelled?: true;
-    }): void;
-    /** A live task's runner went silent (ADR-0018's idle timer); paused while it waits on input, a checkpoint or an approval. */
-    onTaskIdle?(data: {
-        taskId: string;
-        idleSince: string;
-    }): void;
-    onReviewNeeded?(data: {
-        tasks: Task[];
-        planRunners: RunnerId[];
-    }): void;
-    onReviewApproved?(data: {
-        tasks: Task[];
-    }): void;
-    onCheckpoint?(data: {
-        taskId: string;
-        taskTitle: string;
-        summary: string;
-    }): void;
-    /**
-     * The isolation run record changed and should be persisted with the plan.
-     * `detached` is the record of a run another plan has replaced since — a
-     * release that outlived a plan load — for the session it belongs to.
-     */
-    onIsolationChanged?(detached?: IsolationRun): void;
-    /** A run did not start: the tree is dirty, and the user picks stash or no isolation. `repos` names the dirty repos of a group. */
-    onIsolationBlocked?(data: {
-        reason: 'dirty';
-        repos: string[];
-    }): void;
-    /** An isolated run settled; emitted before `onExecutionComplete`, which surfaces treat as terminal. */
-    onIsolationHandoff?(handoff: IsolationHandoff): void;
-    /**
-     * What a run says about how it isolates — the fallback to the workspace root,
-     * shared paths, copies, a stash. Beside the notification channel, which a
-     * daemon may leave unwired, so a surface without toasts can still show it.
-     */
-    onIsolationNotice?(data: {
-        level: 'info' | 'warn' | 'error';
-        message: string;
-    }): void;
+{
+    type: 'task_skills';
+    skills: TaskSkillSnapshot[] | TaskSkillNotice[];
 }
 /**
- * A message or interrupt a task cannot take: it is not running, or it is
- * waiting on something a message does not answer.
- * The request is wrong, not the orchestrator, so a surface says why.
+ * A turn began by delivering `message`; `messageId` names it when it had been
+ * queued, `forced` when it was force sent. `from` on this and the other
+ * message events marks one Ordewell sent rather than the user.
  */
-declare class TaskControlError extends Error {
-    constructor(message: string);
-}
-type AttemptPhase = 'starting' | 'running' | 'integrating';
-/** Read-only view of a task's live attempt. */
-interface TaskAttemptSnapshot {
-    taskId: string;
-    attempt: number;
-    phase: AttemptPhase;
-    sessionId: string | null;
-    runner: string;
-    cwd: string | null;
-    startedAt: string;
-    skills: readonly TaskSkillSnapshot[];
+ | {
+    type: 'turn_start';
+    message: string;
+    messageId?: string;
+    forced?: boolean;
+    from?: TaskMessageFrom;
 }
 /**
- * The wiring a {@link TaskOrchestrator} runs on, every collaborator resolved.
- * {@link TaskOrchestrator.compose} is the only production caller; tests build
- * one through it too. The constructor makes nothing itself, so there is exactly
- * one place defaults live.
+ * A turn began by running the runner's own command `/name args` (#66): the
+ * `turn_start` of a command turn. `messageId` names it when it had been queued.
  */
-interface TaskOrchestratorDeps {
-    config: IConfig;
-    notifications: INotification;
-    runner: IRunner;
-    store: PlanStore;
-    output: TaskOutputSource;
-    /** The plan's isolation run and the open run's lifecycle (ADR-0013). */
-    runs: IsolationRunController;
-    /** A passed attempt's work onto the integration branch, and any conflict repair. */
-    landing: Landing;
-    registry: RunnerRegistry | null;
-    /** The workspace root, read at call time — VS Code can change it. */
-    workspaceRoot: () => string;
-    /** The workspace's own variables for a task's cwd (ADR-0016). */
-    workspaceEnv: (cwd: string) => Promise<WorkspaceEnv>;
-    /** The skill catalog over workspace roots, as {@link workspaceSkillRoots} orders them — read at each spawn. */
-    skillsAt: (roots: readonly string[]) => SkillLookup;
-    /** What the task's last saved attempt did, or null when it left no log (ADR-0020). */
-    previousAttemptFromLog: (taskId: string) => string | null;
-    /**
-     * The open run's settings, read as each automatic merge is decided rather
-     * than copied when the run opens, so a change to the run under way applies
-     * at once (ADR-0030); absent before any run.
-     */
-    runSettings: () => SchedulerRunSettings | undefined;
+ | {
+    type: 'command';
+    name: string;
+    args?: string;
+    messageId?: string;
+}
+/** What the running command printed, for one that runs without the model. */
+ | {
+    type: 'command_output';
+    text: string;
+}
+/** The runner compacted its own context, asked to or on its own. */
+ | {
+    type: 'compaction';
+    trigger: 'manual' | 'auto';
+    preTokens?: number;
+    postTokens?: number;
+}
+/** What the runner loaded from the user's and the project's setup, as its process started. */
+ | {
+    type: 'runner_loaded';
+    commands: RunnerCommand[];
+    mcpServers: RunnerMcpServer[];
+} | {
+    type: 'turn_end';
+    reason: StructuredTurnEnd;
+} | {
+    type: 'text_delta';
+    text: string;
+}
+/** A complete run of the agent's reply, authoritative over the deltas streamed for it. */
+ | {
+    type: 'text';
+    text: string;
+} | {
+    type: 'thinking_delta';
+    text: string;
+    subagentId?: string;
+} | {
+    type: 'thinking';
+    text: string;
+    subagentId?: string;
+}
+/** `args` is the call's arguments as JSON, exactly as the runner announced them. */
+ | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    args: string;
+    subagentId?: string;
+}
+/** `omittedLines` is set when {@link trimToolOutput} cut the middle of `output`. */
+ | {
+    type: 'tool_result';
+    id: string;
+    output: string;
+    success: boolean;
+    omittedLines?: number;
+    subagentId?: string;
+} | {
+    type: 'subagent_started';
+    subagentId: string;
+    brief: string;
+    model?: string;
+} | {
+    type: 'subagent_finished';
+    subagentId: string;
+    outcome: SubagentOutcome;
+    digest: string;
+} | {
+    type: 'usage';
+    record: UsageRecord;
 }
 /**
- * What a caller supplies to {@link TaskOrchestrator.compose}; every optional
- * one gets its default there. This is what a host or test chooses, not the
- * resolved wiring the orchestrator itself runs on.
+ * Waiting in Ordewell's queue — again, for a message the runner was handed
+ * and let go of (ADR-0023, D4). `forced` moves it ahead of the rest (F2).
  */
-interface TaskOrchestratorOptions {
-    config: IConfig;
-    notifications: INotification;
-    runner: IRunner;
-    store?: PlanStore;
-    output?: TaskOutputSource;
-    isolation?: IWorktreeIsolation;
-    registry?: RunnerRegistry | null;
-    workspaceRoot?: () => string;
-    workspaceEnv?: (cwd: string) => Promise<WorkspaceEnv>;
-    skillsAt?: (roots: readonly string[]) => SkillLookup;
-    previousAttemptFromLog?: (taskId: string) => string | null;
-    runSettings?: () => SchedulerRunSettings | undefined;
+ | {
+    type: 'message_queued';
+    messageId: string;
+    text: string;
+    forced?: boolean;
+    from?: TaskMessageFrom;
+} | {
+    type: 'message_removed';
+    messageId: string;
+} | {
+    type: 'message_undelivered';
+    messageId: string;
+    text: string;
+    from?: TaskMessageFrom;
+}
+/** The runner accepted a queued message into its running turn; it can no longer be taken back. */
+ | {
+    type: 'message_handed_over';
+    messageId: string;
 }
 /**
- * The pure scheduler. Owns execution state (`running`, `planStatus`,
- * `reviewApproved`, the live task attempts, the start hold) and the verifier.
- * All task-shaped state — the plan tree, the flat index, the completed set
- * — lives in {@link PlanStore}, injected at construction. The orchestrator
- * calls `store.markCompleted(id)` / `store.markFailed(id)` instead of mutating
- * task state directly. A task completes only after the runner reports it done
- * through `task_complete` on its attempt's token; process exit without that
- * evidence is a visible failure and does not unblock dependent work.
+ * The model read a message inside its running turn (ADR-0023, Q2), logged
+ * where it read it. A message that opened a turn is that turn's `turn_start`.
  */
-declare class TaskOrchestrator {
-    private config;
-    private notifications;
-    private runner;
-    private store;
-    private output;
-    private attempts;
-    private verifier;
-    private running;
-    private planStatus;
-    /** Planner turns in flight that new starts wait for (ADR-0029); running attempts carry on. */
-    private startHolds;
-    private reviewApproved;
-    private autoMergeBlocked;
-    private mergesInFlight;
-    private retryCounts;
-    private spawnCounts;
-    /** A full-plan run a usage-limit pause holds: no new start until the reset resumes it. */
-    private heldOnLimit;
-    /**
-     * A full-plan run that ended with failed tasks and the tasks they block
-     * (ADR-0034). A retry of a failed task continues it, so what it blocked
-     * starts once it passes — without this the retried task ran alone.
-     */
-    private endedOnFailure;
-    /** A Merge all is under way: no ops task starts until it ends (ADR-0020). */
-    private merging;
-    /** The last "waiting for Merge all" notice, so a run paused at a gate says it once, not on every tick. */
-    private gateNotice;
-    /** The workspace's own variables for a task's cwd (ADR-0016); swapped out in tests. */
-    private workspaceEnv;
-    /** What the workspace env has already warned about, so a run says it once, not per task. */
-    private envWarnings;
-    /**
-     * Tasks pulled out of auto-scheduling (user-cancelled or failed to spawn).
-     * They stay 'pending' — "not executed" — but the scheduler skips them until
-     * the user retries or force-starts, which would otherwise loop forever on a
-     * task whose spawn always throws.
-     */
-    private onHold;
-    /**
-     * Tasks Mark complete is landing after it ended their attempt: in progress
-     * with no attempt for as long as that takes, and not orphans for it.
-     */
-    private completing;
-    /** One wait per runner for its usage limit to reset; the tasks it resumes, and when, are on the plan (#84). */
-    private limitWaits;
-    /**
-     * The plan's isolation run and the open run's lifecycle (ADR-0013); see
-     * {@link IsolationRunController}. Read and acted on there directly, except
-     * Merge all: that goes through {@link mergeRun}, which keeps it apart from
-     * ops tasks and starts the tasks its merge lets through.
-     */
-    readonly runs: IsolationRunController;
-    /** A passed attempt's work onto the integration branch, and the conflict repair a landing may need. */
-    private landing;
-    private registry;
-    private workspaceRootFn;
-    private observers;
-    private skillsAt;
-    private previousAttemptFromLog;
-    private runSettings;
-    constructor(deps: TaskOrchestratorDeps);
-    /**
-     * The composition root: resolves every optional collaborator and wires the
-     * isolation listener that the constructor cannot, because it needs the
-     * instance's own (private) emit seam. Nothing else in the
-     * codebase constructs an orchestrator, so this is the one place defaults
-     * live — a host or test supplies what it cares about and gets the rest.
-     */
-    static compose(options: TaskOrchestratorOptions): TaskOrchestrator;
-    /** Advisory silence timestamp for a task's live runner, or null if not idle. */
-    getIdleSince(taskId: string): string | null;
-    /**
-     * What an ops retry is told about the attempt before. The saved log is read
-     * whether or not the session was reloaded, so both behave alike; the output
-     * buffer is the fallback for a runner that has no log. A reload clears the
-     * attempt count along with the buffer, so a retry made since is what says
-     * there was an attempt to report on.
-     */
-    private opsPreviousAttempt;
-    /** Recent clean output of a task's latest attempt, running or ended; null if it never ran. */
-    getLiveOutput(taskId: string, opts: LiveTailOptions): LiveTail | null;
-    get storeInstance(): PlanStore;
-    /**
-     * The variables a task's agent gets from its workspace. What cannot be
-     * applied is said once — silently starting without them is how agents ran
-     * under the wrong account when an edited `.envrc` was left unallowed.
-     */
-    private envForTask;
-    approveCheckpoint(taskId: string): void;
-    rejectCheckpoint(taskId: string, reason?: string): void;
-    /** What the task's waiting checkpoint asks, whole; undefined once it settles or when none waits. */
-    getCheckpointQuestion(taskId: string): string | undefined;
-    awaitsCheckpoint(taskId: string): boolean;
-    /**
-     * Send a structured task a user message (ADR-0018, M1). Mid-turn it queues
-     * behind the turn; a task waiting for input takes it at once and is back in
-     * progress. Returns the message's id, for {@link removeQueuedTaskMessage}.
-     */
-    sendTaskMessage(taskId: string, text: string): string;
-    /**
-     * Force send (ADR-0023, F1–F3): interrupt the running turn and deliver the
-     * message as the next one, ahead of anything queued, without the task
-     * waiting for input in between. A task already waiting for input just takes it.
-     */
-    forceSendTaskMessage(taskId: string, text: string): string;
-    /**
-     * Run the task runner's own command `/name args` (#66) as a turn of its
-     * own, waiting behind a running turn as a message would. Ordewell carries
-     * it; what it does is the runner's business (#24).
-     */
-    invokeTaskCommand(taskId: string, name: string, args?: string): string;
-    private messageTask;
-    /** Force send a message not yet delivered, queued or handed over; false once it was delivered. */
-    forceSendQueuedTaskMessage(taskId: string, id: string): boolean;
-    /** Take back a message still queued behind a turn; false once it was delivered. */
-    removeQueuedTaskMessage(taskId: string, id: string): boolean;
-    /** Stop a structured task's running turn; it then waits for input like any turn that ends without a `task_complete` call. */
-    interruptTask(taskId: string): Promise<void>;
-    /** What is waiting for a structured task's turn to end; empty for any other task. */
-    getQueuedTaskMessages(taskId: string): QueuedTaskMessage[];
-    private runnerSession;
-    /**
-     * A structured turn that ended without a `task_complete` call (ADR-0018, W1). No
-     * verdict is guessed: the task waits for input, unless a checkpoint in the
-     * same turn already has it waiting, or a queued message went straight out —
-     * the session never passes through idle then, so nothing flickers. The first
-     * turn of an attempt to end that way, cleanly, gets the completion reminder
-     * instead: weaker models often finish the work and report in prose.
-     */
-    private onTurnEnd;
-    subscribe(observer: OrchestratorObserver): () => void;
-    /**
-     * Isolated per observer: one that throws must not take down the scheduler
-     * or stop the remaining observers from hearing the event.
-     */
-    private emit;
-    get isRunning(): boolean;
-    /**
-     * A runner is executing *right now*. Narrower than {@link isRunning}, which
-     * also covers the armed-but-idle scheduler `tick()` deliberately leaves
-     * behind when a plan is paused on a user task, a checkpoint or a hold —
-     * nothing is executing then, so nothing is reading the plan mid-mutation.
-     */
-    get hasLiveWork(): boolean;
-    get isReviewApproved(): boolean;
-    /** The scheduler is driving the plan: ready tasks start on their own as slots free. Narrower than {@link isRunning}. */
-    get isScheduling(): boolean;
-    /**
-     * A full-plan run with nothing starting that something still resumes: a
-     * usage limit's reset, or a retry of a failed task its blocked tasks wait on.
-     */
-    get awaitsResume(): boolean;
-    get status(): 'approved' | 'running' | 'completed';
-    get activeTaskIds(): string[];
-    /** Task id → session id of every attempt whose runner is up; a spawn in flight has no session yet. */
-    get activeSessionMap(): Map<string, string>;
-    getAttempt(taskId: string): TaskAttemptSnapshot | undefined;
-    /** A planner turn holds new starts: what is ready starts when it releases them. */
-    get startsHeld(): boolean;
-    /**
-     * Hold the scheduler's new starts while a planner turn decides what runs
-     * next, so its edits do not race a task that would otherwise start under
-     * it. Running attempts are untouched. The release is idempotent and starts
-     * nothing itself: whoever releases ticks, which starts what became ready.
-     */
-    holdStarts(): () => void;
-    /**
-     * "Merge all"; a settled run that merged everything is cleared up and
-     * forgotten. During a run it merges what has landed and the run goes on:
-     * the tasks waiting at a merge gate for that work then start (ADR-0020).
-     * Never alongside ops work, either way round ({@link mergeExcludes}).
-     */
-    mergeRun(): Promise<IsolationMergeResult>;
-    private mergeLanded;
-    /**
-     * Close the settled run. With merge at gates automatically on, landed work
-     * not merged yet is merged first, through the gate's path, so no surface
-     * hears of a handoff for a run about to merge; one that stopped is handed
-     * over as before.
-     */
-    private closeRun;
-    /**
-     * The run as a surface offers Merge all mid-run (ADR-0020): what has landed
-     * and is not merged, and whether the run is paused at its gates with nothing
-     * else running. Null once everything landed is merged.
-     */
-    runMergeView(): RunMergeView | null;
-    /**
-     * The dependencies an ops or user task waits on at its merge gate: those
-     * whose landed work is not in the user's branch yet (ADR-0020). Empty once
-     * the task has started, and for every other task.
-     */
-    getMergeGate(taskId: string): string[];
-    /** The failed tasks a task not started yet waits on, through its dependencies (ADR-0034); empty when it is not blocked. */
-    getBlockedBy(taskId: string): string[];
-    loadPlan(tasks: readonly Task[], planRunners?: RunnerId[]): void;
-    /**
-     * Adopt an edited plan without letting go of the run in progress. Everything
-     * the scheduler owns — live sessions, holds, retry counts, the verifier and
-     * the review approval — survives, because `loadPlan` clears all of it and a
-     * mid-run edit is not a new run. Only the tasks change.
-     *
-     * The ids with live sessions are defended: one dropped from the edited plan is
-     * carried over (its verdict still has to land somewhere), and one whose status
-     * the snapshot predates is put back to `in_progress` — adopting the snapshot's
-     * "pending" would offer the scheduler work a runner is already doing.
-     *
-     * A failed task stays failed, unlike a plan load's fresh chance: an edit is
-     * not a retry, and the tasks it blocks wait for that retry (ADR-0034).
-     */
-    reconcilePlan(newTasks: Task[], planRunners?: RunnerId[]): void;
-    start(origin?: RunOrigin): Promise<void>;
-    /** A usage-limit pause holds the run: spawning more would spend the same exhausted limit. */
-    private holdOnLimit;
-    stop(): void;
-    /** Name the tasks a stop took down, so none is mistaken for one still at work. */
-    private sayStopped;
-    /**
-     * A task in progress with no attempt has nothing running it: a stop, a plan
-     * load or anything else that ended its attempt left its status behind. It
-     * is put back to not started, and said, so it can be retried rather than
-     * read as running — or, in an isolated run, count as live work forever.
-     */
-    private recoverOrphans;
+ | {
+    type: 'message_delivered';
+    messageId: string;
+    text: string;
+    from?: TaskMessageFrom;
+}
+/** The agent's own words for a failed turn. */
+ | {
+    type: 'error';
+    message: string;
+}
+/**
+ * The runner asked to use a tool its mode does not cover (ADR-0018, A1).
+ * `approvalId` is what the answer is given under; `args` is the call's
+ * arguments as JSON; `allowForTask` says the runner offered its own
+ * session-scoped grant. `decided` is set when the request was never left
+ * open — an Ordewell tool or an auto-approving mode — so a surface does not
+ * offer to answer what is already answered (it is still followed by the
+ * matching `approval_decided`, which a reader may rely on).
+ */
+ | {
+    type: 'approval_requested';
+    approvalId: string;
+    tool: string;
+    args: string;
+    allowForTask: boolean;
+    toolCallId?: string;
+    decided?: ApprovalDecision['decision'];
+} | {
+    type: 'approval_decided';
+    approvalId: string;
+    decision: ApprovalDecision['decision'];
+    note?: string;
+}
+/** The request went unanswered: the runner withdrew it, or its process ended. */
+ | {
+    type: 'approval_withdrawn';
+    approvalId: string;
+}
+/**
+ * The runner's process ended. A call it had not reported back on is not
+ * running any more: a task's runner is ended the moment its `task_complete`
+ * lands, often before it reports that call's result.
+ */
+ | {
+    type: 'runner_ended';
+};
+/**
+ * Keep a tool result's head and tail. A build log or a whole file read can
+ * run to megabytes, and every attempt's file keeps it for good; the ends are
+ * where a reader looks — the command's start, and how it finished.
+ */
+declare function trimToolOutput(output: string): {
+    output: string;
+    omittedLines?: number;
+};
+/**
+ * The log entry for one structured event, or null for what the log does not
+ * keep: background-agent launches, which the subagent's own events already show.
+ */
+declare function toTaskLogEvent(event: StructuredEvent): TaskLogEvent | null;
+/** A log as a surface is sent it, live or read back: everything but the skills' bodies. */
+declare function taskLogForSurface(events: readonly TaskLogEvent[]): TaskLogEvent[];
+/**
+ * Merge runs of deltas into one event each. Deltas arrive a few characters at
+ * a time; merged, a batch is one message on the wire and one line on disk,
+ * and the view folds to the same blocks either way.
+ */
+declare function coalesceTaskLog(events: readonly TaskLogEvent[]): TaskLogEvent[];
+/**
+ * What an attempt did to the world, for the retry of a task whose effects
+ * outlive it (ADR-0020): one line per tool call and how it ended.
+ */
+declare function digestTaskLog(events: readonly TaskLogEvent[], maxCalls: number): string;
+
+type SerializedTaskStatus = {
+    id: string;
+    status: Task['status'];
+    verdict: {
+        outcome: 'pass' | 'fail';
+        reason: string;
+        checks: Verdict['checks'];
+    } | null;
+    /** Advisory silence timestamp from VerdictEngine — not part of task status semantics. */
+    idleSince?: string | null;
+    /** Absent unless the plan has an isolation run, so a shared-root plan's updates are unchanged. */
+    isolation?: TaskIsolation;
+    /** What an `awaiting_user` task waits on, when it was saved (ADR-0018, W1). */
+    awaitingReason?: AwaitingReason;
+    /** When a task paused on a usage limit resumes on its own (ISO time); absent when it waits for a manual retry. */
+    resumeAt?: string;
+    /** Why a `skipped` task was skipped; absent when no reason was given, and on any other status. */
+    skipReason?: string;
+    /** The whole question of the checkpoint the task waits at; absent when it waits at none. */
+    checkpoint?: string;
+    /** Messages waiting for a structured task's turn to end, oldest first; absent when there are none. */
+    queued?: QueuedTaskMessage[];
+    /** Set when the task can be continued in its saved runner session (ADR-0018, K1); the id itself stays in the daemon. */
+    continuable?: true;
     /**
-     * Task ids still live, whose worktrees no clean-up of the whole run may
-     * take: an attempt is running them, or the plan has them in progress or
-     * waiting on the user mid-attempt — at a checkpoint, or for input. One
-     * waiting on the user's decision instead (a conflict, a usage limit, files
-     * an ops task changed) is not: no runner is at work on it, and a clean-up
-     * keeps what it holds on a branch before its worktree goes.
+     * How many of a structured task's runner requests wait for an answer
+     * (ADR-0018, A1) — "waiting for approval", which leaves `status` alone.
+     * Absent when none do.
      */
-    private liveTaskIds;
+    awaitingApproval?: number;
     /**
-     * Whether the run may close with its handoff: no task is live. A handoff
-     * tells the user the run has finished, and a Merge all after it clears the
-     * run up, so neither may happen under a task the plan still shows at work.
+     * The ancestors an ops or user task waits on at its merge gate: their
+     * work has landed but is not merged into the user's branch (ADR-0020).
+     * Absent when it waits for no Merge all.
      */
-    private get settled();
+    mergeGate?: string[];
+    /** The ancestors, by title, a force start went past the merge gate of (ADR-0020). */
+    forcedPastGate?: string[];
     /**
-     * The boundary a verdict crosses: nothing awaits the verifier's listener, so
-     * a throw from reading the output, landing, releasing a worktree or the tick
-     * after would be an unhandled rejection — and an attempt left integrating is
-     * live work forever. One that never settled fails (a repair waits on the
-     * user, as its conflict did) and blocks only its dependents; either way the
-     * run says why and goes on.
+     * Added after the user approved the plan and not approved since, so the
+     * scheduler leaves it for them (ADR-0035). Absent for any other task.
      */
-    private deliverVerdict;
-    /** Work nothing awaits: a rejection is said, not left unhandled. */
-    private unawaited;
-    private onVerdict;
-    private afterVerdict;
-    /**
-     * A repair's verdict never replaces the verdict the task's own work earned,
-     * and a repair that does not land leaves the task waiting on the user —
-     * never a failed task, so never one that blocks its dependents.
-     */
-    private settleRepair;
-    /**
-     * Hand an attempt's verdict to Landing. The attempt stays live while that
-     * settles — it may wait on the module's merge queue — so a cancel, retry or
-     * stop in that window still wins, and waits for the merge before tearing the
-     * worktree down; nothing counts the task as done before its work is on the
-     * integration branch.
-     */
-    private land;
-    /** Settle a task by how its landing went; `onLanded` is what the path that landed it adds to completing it. */
-    private applyLanding;
-    /**
-     * Work that did not land waits on the user — it never fails the task or
-     * blocks its dependents — unless its conflict is owed a repair, which takes
-     * the slot the ending attempt freed and never one more than the run allows.
-     */
-    private settleUnlanded;
-    private landResolved;
-    getReadyTasks(): Task[];
-    private readiness;
-    private mergesAutomatically;
-    /**
-     * The user changed the run settings under an open run (ADR-0030). The
-     * scheduler reads them at each decision it makes from them, so a merge gate
-     * already reached is merged now rather than at the next event. Fire-and-forget
-     * — no caller waits on the change — and its failure is said through
-     * {@link unawaited}, never left unhandled.
-     */
-    runSettingsChanged(): void;
-    private openRun;
-    /**
-     * Open the run a task starts in, and decide whether it isolates if the
-     * task's next attempt needs that ({@link decidesIsolation}). False while a
-     * dirty tree waits on the user; `resume` is what their choice replays.
-     */
-    private openFor;
-    /** The kind a task's next attempt starts as, short of a repair or a continue: what is weighed before one exists. */
-    private nextAttemptKind;
-    /**
-     * 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
-     * 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.
-     */
-    releaseTask(taskId: string): Promise<void>;
-    markTaskComplete(taskId: string): Promise<void>;
-    /**
-     * Undo a completion: return the task to "not executed" — pending, verdict and
-     * summary dropped, archive entry removed. It is put on hold like a cancel, so
-     * a running plan does not immediately re-spawn the work the user just
-     * un-marked; Retry / Force Start / Run release the hold. Dependents fall back
-     * to waiting on their own, because the scheduler gates on `isCompleted`.
-     */
-    markTaskIncomplete(taskId: string): Promise<void>;
-    /**
-     * Skip: end a task as `skipped`, with no verdict and nothing of its work
-     * landed. Its worktree is kept, as a failed attempt's is, so the user can
-     * still look at it or Mark complete it later. Its dependents go ahead
-     * without it, and a run that ended on a failure continues for them, as a
-     * retry would continue it. A running task is stopped before it is skipped.
-     */
-    skipTask(taskId: string, reason?: string, origin?: RunOrigin): Promise<void>;
-    private logAndArchive;
-    retryTask(taskId: string, origin?: RunOrigin): Promise<void>;
-    /**
-     * Continue a finished structured task in its saved runner session (ADR-0018,
-     * K1): a retry whose first turn is the user's message, sent to the session
-     * the task ended in rather than a fresh one given its prompt again. The
-     * worktree keeps the same path, where the runner keeps its sessions, and
-     * restores the previous work so that session's memory matches its files.
-     */
-    continueTask(taskId: string, message: string, origin?: RunOrigin): Promise<void>;
-    /**
-     * Keep a task paused on its runner's usage limit from resuming on its own:
-     * it waits for a manual retry, as one whose reset time could not be read
-     * does. What a surface's cancel calls, and what moving the task to another
-     * runner has to call first. False when no resume was scheduled for it.
-     */
-    cancelScheduledResume(taskId: string): boolean;
-    /** Run before writing assignments so cancellation sees the old runner's shared wait. */
-    releaseMovedResume(taskId: string, changes: Partial<Task>): Partial<Task>;
-    /**
-     * A task's attempt stopped on its runner's usage limit, without a
-     * completion call. Failing would paint a red X on a task that only has to
-     * wait, and spawning more tasks would spend the same exhausted limit, so the
-     * task pauses and the run holds. When the runner said when its limit
-     * resets, the task joins its runner's wait and resumes on its own then
-     * (#84); otherwise, or when it was resumed a moment ago and hit the limit
-     * again, it waits for the user to retry it.
-     */
-    private pauseOnLimit;
-    /**
-     * The limit arrived as the turn's error with the runner still up: the
-     * attempt ends here, as its verdict would have ended it, so a resume is a
-     * continue in a fresh process (ADR-0018, L1/K1).
-     */
-    private stopOnLimit;
-    /** The tasks waiting on `runner`'s reset to resume on their own. */
-    private waitingOn;
-    /**
-     * Arm `runner`'s one wait for the latest resume time among its tasks, and
-     * put that time on each of them, so they resume together.
-     */
-    private armLimitWait;
-    /**
-     * The waits a loaded plan still owes. A resume time that passed while
-     * nothing was running — the daemon was down, say — resumes at once.
-     */
-    private rearmLimitWaits;
-    /**
-     * Resume a task paused on its runner's usage limit now, in its saved
-     * session, once the user says the limit has reset early. The limit is the
-     * runner's account's, so every task waiting on that runner's reset resumes
-     * with it, as at the reset itself. `message` follows the reset notice in the
-     * same continuation. A resumed attempt that hits the limit again at once
-     * waits for the user, as an automatic resume's does: that is what keeps a
-     * caller from resuming it round and round.
-     */
-    resumeNow(taskId: string, origin?: RunOrigin, message?: string): Promise<void>;
-    private resumeAfterLimit;
-    /**
-     * Retry a task paused on a usage limit, continuing its saved session where
-     * it left one (ADR-0018, K1), then release the hold the pause put on the
-     * run once nothing else waits on a reset.
-     */
-    private resumeTask;
-    /**
-     * Manually start a single AI task right now, bypassing dependency/readiness
-     * gating (the "force start" affordance on a task card). Reuses the scheduler's
-     * own startTask so a force-started task gets the same augmented prompt, session
-     * tracking, and exit handling — callers must not re-spawn the runner themselves.
-     * No-op if the task is unknown, not an AI task, or already running.
-     */
-    forceStartTask(taskId: string, origin?: RunOrigin): Promise<void>;
-    private refuseOpsDuringMerge;
-    /**
-     * A force start passes a merge gate (ADR-0020), and the surface confirmed it
-     * first; the choice is kept on the task and said, because the work it acts
-     * on is not in the user's branch.
-     */
-    private notePastGate;
-    /**
-     * Run exactly one task outside full-plan scheduling. The active/starting
-     * 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;
-    getTotalCount(): number;
-    isAllComplete(): boolean;
-    isAnyFailed(): boolean;
-    approveReview(origin?: RunOrigin): Promise<void>;
-    tick(): Promise<void>;
-    /** How a run that ended on failures ends: what it finished, what failed, and what that blocks. */
-    /** Skipped work is not completed work, so a run with any says so rather than that everything completed. */
-    private sayFinished;
-    private sayEndedOnFailure;
-    /** Whether the scheduler may start `id` now: it passes every readiness gate and a slot is free. */
-    private stillReady;
-    /**
-     * A run paused at merge gates says so, as plainly as a task that waits on
-     * the user: which tasks wait, and that Merge all lets them go on (ADR-0020).
-     */
-    private sayGate;
-    private startTask;
-    /**
-     * The fallible half of starting a task: resolving its cwd/worktree and
-     * spawning the runner. Resolves false when the attempt never committed —
-     * abandoned because it was ended from under it, or a failed spawn already
-     * unwound (both leave `startTask` with nothing further to announce).
-     */
-    private spawnAttempt;
-    /** For a skill the main checkout has, the folder a worktree only gets once it is committed. */
-    private uncommittedSkillFolder;
-    /**
-     * The roots whose `.ordewell/skills/` an attempt at `cwd` reads: in a repo
-     * group, `cwd` holds each repo — a worktree of it when isolated, the
-     * workspace's own checkout when not — and no folder of its own (ADR-0014).
-     */
-    private skillRoots;
-    /**
-     * A continue whose runner never announced the session it was told to
-     * resume. Nothing was continued, and nothing fresh was started in its place.
-     */
-    private unresumed;
-    /**
-     * A spawn whose attempt ended while it was in flight: kill what it produced
-     * and take back the claim it made. Only the claim — whatever ended the
-     * attempt may have decided the task since (mark complete, cancel, retry).
-     */
-    private abandonSpawn;
-    private tell;
-    private say;
-    /**
-     * Replay the start a dirty tree turned away. `stash` puts the user's tracked
-     * changes on the git stash first, so the run isolates; `shared` runs this one
-     * run in the workspace root, knowingly.
-     */
-    continueBlockedRun(how: 'stash' | 'shared'): Promise<void>;
-    /**
-     * The one way an attempt ends. Dropping the record is itself what
-     * invalidates a spawn still in flight ({@link startTask} kills the session
-     * it receives for an attempt that is no longer current).
-     *
-     * A user interruption also bumps the verifier's generation *before* stopping
-     * the runner: a runner may fire onExit synchronously from
-     * stop(), and if that exit reaches VerdictEngine under the still-valid
-     * generation it delivers a verdict that marks the task 'completed' for one
-     * tick — long enough for the scheduler to start a dependent task. Stop and
-     * load reset the whole verifier themselves.
-     */
-    private endAttempt;
-    /** Kept on the task once the attempt ends, so a continue can resume it after a reload (ADR-0018, K1). */
-    private saveNativeSession;
-    private endAllAttempts;
+    waitsForApproval?: true;
+    attemptUsage?: AttemptUsage[];
+};
+/**
+ * Landed work not yet in the user's branch. `paused` means the running plan
+ * waits at a merge gate with no attempts active.
+ */
+interface RunMergeView {
+    waitingAtGate: boolean;
+    paused: boolean;
+    repos: IsolationHandoff['repos'];
+    landed: IsolationHandoff['landed'];
 }
-
-type SerializedTaskStatus = {
+type SerializedTask = {
     id: string;
-    status: Task['status'];
-    verdict: {
-        outcome: 'pass' | 'fail';
-        reason: string;
-        checks: Verdict['checks'];
-    } | null;
-    /** Advisory silence timestamp from VerdictEngine — not part of task status semantics. */
-    idleSince?: string | null;
-    /** Absent unless the plan has an isolation run, so a shared-root plan's updates are unchanged. */
-    isolation?: TaskIsolation;
-    /** What an `awaiting_user` task waits on, when it was saved (ADR-0018, W1). */
-    awaitingReason?: AwaitingReason;
-    /** When a task paused on a usage limit resumes on its own (ISO time); absent when it waits for a manual retry. */
-    resumeAt?: string;
-    /** Why a `skipped` task was skipped; absent when no reason was given, and on any other status. */
-    skipReason?: string;
-    /** The whole question of the checkpoint the task waits at; absent when it waits at none. */
-    checkpoint?: string;
-    /** Messages waiting for a structured task's turn to end, oldest first; absent when there are none. */
-    queued?: QueuedTaskMessage[];
-    /** Set when the task can be continued in its saved runner session (ADR-0018, K1); the id itself stays in the daemon. */
-    continuable?: true;
-    /**
-     * How many of a structured task's runner requests wait for an answer
-     * (ADR-0018, A1) — "waiting for approval", which leaves `status` alone.
-     * Absent when none do.
-     */
-    awaitingApproval?: number;
-    /**
-     * The dependencies an ops or user task waits on at its merge gate: their
-     * work has landed but is not merged into the user's branch (ADR-0020).
-     * Absent when it waits for no Merge all.
-     */
-    mergeGate?: string[];
-    /** The dependencies, by title, a force start went past the merge gate of (ADR-0020). */
-    forcedPastGate?: string[];
-    attemptUsage?: AttemptUsage[];
-};
-/**
- * Landed work not yet in the user's branch. `paused` means the running plan
- * waits at a merge gate with no attempts active.
- */
-interface RunMergeView {
-    waitingAtGate: boolean;
-    paused: boolean;
-    repos: IsolationHandoff['repos'];
-    landed: IsolationHandoff['landed'];
-}
-type SerializedTask = {
-    id: string;
-    order: number;
-    title: string;
-    type: string;
-    /** Without it a plan broadcast after a run reads as every task pending. */
+    order: number;
+    title: string;
+    type: string;
+    /** Without it a plan broadcast after a run reads as every task pending. */
     status: Task['status'];
     description: string;
     dependencies: string[];
@@ -1733,6 +1084,22 @@ type SerializedPlan = {
     conversationHistory?: SerializedConversationMessage[];
     prdMarkdown?: string;
 };
+/** What a held edit does to a task once it lands. */
+type HeldEditMark = 'added' | 'changed' | 'removed';
+/**
+ * The plan as the open planner turn's edit would leave it, in plan order with
+ * the removed tasks where they were; flat, a subtask after its parent. `label`
+ * is the task's `#2.1` reference; `mark` is absent for a task the edit leaves
+ * alone. Proposed, not approved: the tasks need the user's go-ahead to run.
+ */
+interface HeldEdit {
+    turnId: string;
+    tasks: Array<{
+        label: string;
+        mark?: HeldEditMark;
+        task: SerializedTask;
+    }>;
+}
 /** How a planner turn ended: the reply kind it settled on, a user stop, or a failure. */
 type PlannerTurnOutcome = 'message' | 'plan' | 'task_ops' | 'stopped' | 'error';
 /**
@@ -1798,6 +1165,16 @@ type SessionMessage =
     turnId: string;
     skill: SkillLoadNotice;
 }
+/**
+ * What the open planner turn's task edit would leave, sent whenever the
+ * edit it holds changes (ADR-0029: it lands as the reply ends). `held` is
+ * null once nothing is held: the edit landed, was refused as it landed, or
+ * the turn ended without it. The plan itself is untouched until it lands.
+ */
+ | {
+    type: 'plan_edit_held';
+    held: HeldEdit | null;
+}
 /**
  * A planner turn is over; nothing more carries its `turnId`. Emitted exactly
  * once per `planner_turn_started`, stop and failure included, after the
@@ -2007,7 +1384,7 @@ type PlanSnapshot = {
     plan: SurfacePlan | SurfacePlanState;
 };
 /** What only the status stream says about a task; a plan refresh keeps these as they were. */
-type RunTaskStatus = Partial<Pick<SerializedTaskStatus, 'verdict' | 'idleSince' | 'isolation' | 'checkpoint' | 'queued' | 'continuable' | 'awaitingApproval' | 'mergeGate' | 'forcedPastGate'>>;
+type RunTaskStatus = Partial<Pick<SerializedTaskStatus, 'verdict' | 'idleSince' | 'isolation' | 'checkpoint' | 'queued' | 'continuable' | 'awaitingApproval' | 'mergeGate' | 'forcedPastGate' | 'waitsForApproval'>>;
 /** A task in the run view: the plan's fields, then the status stream's. */
 type RunTask = Omit<SerializedTask, 'subtasks'> & RunTaskStatus & {
     subtasks: RunTask[];
@@ -2025,6 +1402,8 @@ interface RunView {
     usage?: PlanUsage;
     handoff: IsolationHandoff | null;
     mergeResult: IsolationMergeResult | null;
+    /** The edit the open planner turn holds, as it would leave the plan; absent when it holds none. */
+    heldEdit?: HeldEdit;
 }
 type RunInput = SessionMessage | PlanSnapshot;
 /**
@@ -2040,7 +1419,7 @@ type SessionNotice = {
 };
 type SessionBroadcaster = (msg: SessionMessage) => void;
 declare function serializeTask(t: SurfaceTask): SerializedTask;
-declare function serializeTaskStatus(t: Task, idleSince?: string | null, isolation?: TaskIsolation | null, queued?: readonly QueuedTaskMessage[], awaitingApproval?: number, mergeGate?: readonly string[], checkpoint?: string): SerializedTaskStatus;
+declare function serializeTaskStatus(t: Task, idleSince?: string | null, isolation?: TaskIsolation | null, queued?: readonly QueuedTaskMessage[], awaitingApproval?: number, mergeGate?: readonly string[], checkpoint?: string, waitsForApproval?: boolean): SerializedTaskStatus;
 /** The one place a plan's skill bodies come off before it leaves the session: every wire path that carries plan state goes through here. */
 declare function surfacePlan({ queuedMessages: _carriedOverAtLoad, ...plan }: LegacyPlanState): SurfacePlan;
 declare function surfacePlanState(state: PlanState): SurfacePlanState;
@@ -2057,10 +1436,762 @@ interface ExecutionSummary {
     blocked: number;
     skipped: number;
 }
-declare function executionSummary(tasks: readonly Task[]): ExecutionSummary;
-declare const CHECKPOINT_TRUNCATE_LENGTH = 120;
-/** Truncate a checkpoint summary to a single line of at most CHECKPOINT_TRUNCATE_LENGTH chars. */
-declare function truncateCheckpointSummary(summary: string): string;
+declare function executionSummary(tasks: readonly Task[]): ExecutionSummary;
+declare const CHECKPOINT_TRUNCATE_LENGTH = 120;
+/** Truncate a checkpoint summary to a single line of at most CHECKPOINT_TRUNCATE_LENGTH chars. */
+declare function truncateCheckpointSummary(summary: string): string;
+
+/** What ran an automatic Merge all: a task reaching its merge gate, or the run settling with landed work unmerged. */
+type AutoMergeTrigger = {
+    kind: 'gate';
+    taskId: string;
+} | {
+    kind: 'run_end';
+};
+/**
+ * Who opened a run (ADR-0029): a call the user made, or one made for them; a
+ * call of the supervisor's own; or a usage-limit reset resuming what it paused.
+ * Only the user's starts a run's supervision afresh.
+ */
+type RunOrigin = 'user' | 'supervisor' | 'limit-reset';
+/** What the scheduler reads of the open run's settings, at each decision it makes from them. */
+type SchedulerRunSettings = Pick<RunSettings, 'mergeAtGatesAutomatically'>;
+/**
+ * A start someone asked for, from the moment it was admitted until it has
+ * taken its claim or been let go (ADR-0029): a start waiting on the user's
+ * answer, on a held edit, or on the run to open. Stop counts it as live work,
+ * and a Stop since it was admitted refuses its claim.
+ */
+interface StartAdmission {
+    /** No Stop came since it was admitted. */
+    current(): boolean;
+    /** It claimed, or will not: Stop no longer counts it. Idempotent. */
+    release(): void;
+}
+/** What a start the user's Stop withdrew answers, wherever it was waiting. */
+declare const STOPPED_BEFORE_START = "Not done: stopped before it could start. The run was stopped meanwhile; start it again if it is still wanted.";
+/**
+ * The one notification channel out of the orchestrator. Everything that used
+ * to travel over a separate callback (onRefresh) is an observer event; the
+ * Session subscribes once and turns these into SessionMessages.
+ */
+interface OrchestratorObserver {
+    /** Any task-shaped state changed (store mutation, checkpoint, retry, …). */
+    onTaskChanged?(): void;
+    /**
+     * A run reached an outcome that stands until the user acts — completed,
+     * failed, or awaiting the user — on its own, not as the answer to a call.
+     * Emitted before the `onTaskChanged` that announces it, so a listener can
+     * save the outcome before any surface is told.
+     */
+    onTaskSettled?(data: {
+        taskId: string;
+    }): void;
+    onRunStarted?(data: {
+        origin: RunOrigin;
+    }): void;
+    /** An automatic Merge all settled, at a gate or at the run's end; failures are attention events for a supervisor. */
+    onAutoMerge?(data: {
+        trigger: AutoMergeTrigger;
+        result: IsolationMergeResult;
+    }): void;
+    onTick?(): void;
+    onUsageChanged?(): void;
+    onExecutionComplete?(): void;
+    /**
+     * A task paused on its runner's usage limit, or its resume changed:
+     * `resumeAt` is when it resumes on its own (ISO time), null when it waits
+     * for a manual retry — the reset could not be read, the resume was
+     * cancelled, or the resumed attempt hit the limit again at once.
+     * `cancelled` marks the resume being cancelled, which is no new pause.
+     */
+    onUsageLimitWait?(data: {
+        taskId: string;
+        runner: string;
+        resumeAt: string | null;
+        cancelled?: true;
+    }): void;
+    /** A live task's runner went silent (ADR-0018's idle timer); paused while it waits on input, a checkpoint or an approval. */
+    onTaskIdle?(data: {
+        taskId: string;
+        idleSince: string;
+    }): void;
+    onReviewNeeded?(data: {
+        tasks: Task[];
+        planRunners: RunnerId[];
+    }): void;
+    onReviewApproved?(data: {
+        tasks: Task[];
+    }): void;
+    onCheckpoint?(data: {
+        taskId: string;
+        taskTitle: string;
+        summary: string;
+    }): void;
+    /**
+     * The isolation run record changed and should be persisted with the plan.
+     * `detached` is the record of a run another plan has replaced since — a
+     * release that outlived a plan load — for the session it belongs to.
+     */
+    onIsolationChanged?(detached?: IsolationRun): void;
+    /** A run did not start: the tree is dirty, and the user picks stash or no isolation. `repos` names the dirty repos of a group. */
+    onIsolationBlocked?(data: {
+        reason: 'dirty';
+        repos: string[];
+    }): void;
+    /** An isolated run settled; emitted before `onExecutionComplete`, which surfaces treat as terminal. */
+    onIsolationHandoff?(handoff: IsolationHandoff): void;
+    /**
+     * What a run says about how it isolates — the fallback to the workspace root,
+     * shared paths, copies, a stash. Beside the notification channel, which a
+     * daemon may leave unwired, so a surface without toasts can still show it.
+     */
+    onIsolationNotice?(data: {
+        level: 'info' | 'warn' | 'error';
+        message: string;
+    }): void;
+}
+/**
+ * A message or interrupt a task cannot take: it is not running, or it is
+ * waiting on something a message does not answer.
+ * The request is wrong, not the orchestrator, so a surface says why.
+ */
+declare class TaskControlError extends Error {
+    constructor(message: string);
+}
+type AttemptPhase = 'starting' | 'running' | 'integrating';
+/** Read-only view of a task's live attempt. */
+interface TaskAttemptSnapshot {
+    taskId: string;
+    attempt: number;
+    phase: AttemptPhase;
+    sessionId: string | null;
+    runner: string;
+    cwd: string | null;
+    startedAt: string;
+    skills: readonly TaskSkillSnapshot[];
+}
+/**
+ * The wiring a {@link TaskOrchestrator} runs on, every collaborator resolved.
+ * {@link TaskOrchestrator.compose} is the only production caller; tests build
+ * one through it too. The constructor makes nothing itself, so there is exactly
+ * one place defaults live.
+ */
+interface TaskOrchestratorDeps {
+    config: IConfig;
+    notifications: INotification;
+    runner: IRunner;
+    store: PlanStore;
+    output: TaskOutputSource;
+    /** The plan's isolation run and the open run's lifecycle (ADR-0013). */
+    runs: IsolationRunController;
+    /** A passed attempt's work onto the integration branch, and any conflict repair. */
+    landing: Landing;
+    registry: RunnerRegistry | null;
+    /** The workspace root, read at call time — VS Code can change it. */
+    workspaceRoot: () => string;
+    /** The workspace's own variables for a task's cwd (ADR-0016). */
+    workspaceEnv: (cwd: string) => Promise<WorkspaceEnv>;
+    /** The skill catalog over workspace roots, as {@link workspaceSkillRoots} orders them — read at each spawn. */
+    skillsAt: (roots: readonly string[]) => SkillLookup;
+    /** What the task's last saved attempt did, or null when it left no log (ADR-0020). */
+    previousAttemptFromLog: (taskId: string) => string | null;
+    /**
+     * The open run's settings, read as each automatic merge is decided rather
+     * than copied when the run opens, so a change to the run under way applies
+     * at once (ADR-0030); absent before any run.
+     */
+    runSettings: () => SchedulerRunSettings | undefined;
+    /**
+     * The user's approval record, read at each start (ADR-0035): the Session
+     * owns it, and the scheduler starts nothing outside it.
+     */
+    isApproved: (taskId: string) => boolean;
+}
+/**
+ * What a caller supplies to {@link TaskOrchestrator.compose}; every optional
+ * one gets its default there. This is what a host or test chooses, not the
+ * resolved wiring the orchestrator itself runs on.
+ */
+interface TaskOrchestratorOptions {
+    config: IConfig;
+    notifications: INotification;
+    runner: IRunner;
+    store?: PlanStore;
+    output?: TaskOutputSource;
+    isolation?: IWorktreeIsolation;
+    registry?: RunnerRegistry | null;
+    workspaceRoot?: () => string;
+    workspaceEnv?: (cwd: string) => Promise<WorkspaceEnv>;
+    skillsAt?: (roots: readonly string[]) => SkillLookup;
+    previousAttemptFromLog?: (taskId: string) => string | null;
+    runSettings?: () => SchedulerRunSettings | undefined;
+    /** Every task is approved unless a Session supplies its record: an orchestrator on its own has no user to ask. */
+    isApproved?: (taskId: string) => boolean;
+}
+/**
+ * The pure scheduler. Owns execution state (`running`, `planStatus`,
+ * `reviewApproved`, the live task attempts, the start hold) and the verifier.
+ * All task-shaped state — the plan tree, the flat index, the completed set
+ * — lives in {@link PlanStore}, injected at construction. The orchestrator
+ * calls `store.markCompleted(id)` / `store.markFailed(id)` instead of mutating
+ * task state directly. A task completes only after the runner reports it done
+ * through `task_complete` on its attempt's token; process exit without that
+ * evidence is a visible failure and does not unblock dependent work.
+ */
+declare class TaskOrchestrator {
+    private config;
+    private notifications;
+    private runner;
+    private store;
+    private output;
+    private attempts;
+    private verifier;
+    private running;
+    private planStatus;
+    /** Planner turns in flight that new starts wait for (ADR-0029); running attempts carry on. */
+    private startHolds;
+    /** Bumped by the user's Stop: a start admitted under an older generation never takes its claim. */
+    private stopGeneration;
+    /** Starts admitted and not yet claimed or let go; see {@link StartAdmission}. */
+    private admissions;
+    private reviewApproved;
+    private autoMergeBlocked;
+    private mergesInFlight;
+    private retryCounts;
+    private spawnCounts;
+    /** A full-plan run a usage-limit pause holds: no new start until the reset resumes it. */
+    private heldOnLimit;
+    /**
+     * A full-plan run that ended with failed tasks and the tasks they block
+     * (ADR-0034). A retry of a failed task continues it, so what it blocked
+     * starts once it passes — without this the retried task ran alone.
+     */
+    private endedOnFailure;
+    /** A Merge all is under way: no ops task starts until it ends (ADR-0020). */
+    private merging;
+    /** The last "waiting for Merge all" notice, so a run paused at a gate says it once, not on every tick. */
+    private gateNotice;
+    /** The workspace's own variables for a task's cwd (ADR-0016); swapped out in tests. */
+    private workspaceEnv;
+    /** What the workspace env has already warned about, so a run says it once, not per task. */
+    private envWarnings;
+    /**
+     * Tasks pulled out of auto-scheduling (user-cancelled or failed to spawn).
+     * They stay 'pending' — "not executed" — but the scheduler skips them until
+     * the user retries or force-starts, which would otherwise loop forever on a
+     * task whose spawn always throws.
+     */
+    private onHold;
+    /**
+     * Tasks Mark complete is landing after it ended their attempt: in progress
+     * with no attempt for as long as that takes, and not orphans for it.
+     */
+    private completing;
+    /** One wait per runner for its usage limit to reset; the tasks it resumes, and when, are on the plan (#84). */
+    private limitWaits;
+    /**
+     * The plan's isolation run and the open run's lifecycle (ADR-0013); see
+     * {@link IsolationRunController}. Read and acted on there directly, except
+     * Merge all: that goes through {@link mergeRun}, which keeps it apart from
+     * ops tasks and starts the tasks its merge lets through.
+     */
+    readonly runs: IsolationRunController;
+    /** A passed attempt's work onto the integration branch, and the conflict repair a landing may need. */
+    private landing;
+    private registry;
+    private workspaceRootFn;
+    private observers;
+    private skillsAt;
+    private previousAttemptFromLog;
+    private runSettings;
+    private isApproved;
+    constructor(deps: TaskOrchestratorDeps);
+    /**
+     * The composition root: resolves every optional collaborator and wires the
+     * isolation listener that the constructor cannot, because it needs the
+     * instance's own (private) emit seam. Nothing else in the
+     * codebase constructs an orchestrator, so this is the one place defaults
+     * live — a host or test supplies what it cares about and gets the rest.
+     */
+    static compose(options: TaskOrchestratorOptions): TaskOrchestrator;
+    /** Advisory silence timestamp for a task's live runner, or null if not idle. */
+    getIdleSince(taskId: string): string | null;
+    /**
+     * What an ops retry is told about the attempt before. The saved log is read
+     * whether or not the session was reloaded, so both behave alike; the output
+     * buffer is the fallback for a runner that has no log. A reload clears the
+     * attempt count along with the buffer, so a retry made since is what says
+     * there was an attempt to report on.
+     */
+    private opsPreviousAttempt;
+    /** Recent clean output of a task's latest attempt, running or ended; null if it never ran. */
+    getLiveOutput(taskId: string, opts: LiveTailOptions): LiveTail | null;
+    get storeInstance(): PlanStore;
+    /**
+     * The variables a task's agent gets from its workspace. What cannot be
+     * applied is said once — silently starting without them is how agents ran
+     * under the wrong account when an edited `.envrc` was left unallowed.
+     */
+    private envForTask;
+    approveCheckpoint(taskId: string): void;
+    rejectCheckpoint(taskId: string, reason?: string): void;
+    /** What the task's waiting checkpoint asks, whole; undefined once it settles or when none waits. */
+    getCheckpointQuestion(taskId: string): string | undefined;
+    awaitsCheckpoint(taskId: string): boolean;
+    /**
+     * Send a structured task a user message (ADR-0018, M1). Mid-turn it queues
+     * behind the turn; a task waiting for input takes it at once and is back in
+     * progress. Returns the message's id, for {@link removeQueuedTaskMessage}.
+     */
+    sendTaskMessage(taskId: string, text: string): string;
+    /**
+     * Force send (ADR-0023, F1–F3): interrupt the running turn and deliver the
+     * message as the next one, ahead of anything queued, without the task
+     * waiting for input in between. A task already waiting for input just takes it.
+     */
+    forceSendTaskMessage(taskId: string, text: string): string;
+    /**
+     * Run the task runner's own command `/name args` (#66) as a turn of its
+     * own, waiting behind a running turn as a message would. Ordewell carries
+     * it; what it does is the runner's business (#24).
+     */
+    invokeTaskCommand(taskId: string, name: string, args?: string): string;
+    private messageTask;
+    /** Force send a message not yet delivered, queued or handed over; false once it was delivered. */
+    forceSendQueuedTaskMessage(taskId: string, id: string): boolean;
+    /** Take back a message still queued behind a turn; false once it was delivered. */
+    removeQueuedTaskMessage(taskId: string, id: string): boolean;
+    /** Stop a structured task's running turn; it then waits for input like any turn that ends without a `task_complete` call. */
+    interruptTask(taskId: string): Promise<void>;
+    /** What is waiting for a structured task's turn to end; empty for any other task. */
+    getQueuedTaskMessages(taskId: string): QueuedTaskMessage[];
+    private runnerSession;
+    /**
+     * A structured turn that ended without a `task_complete` call (ADR-0018, W1). No
+     * verdict is guessed: the task waits for input, unless a checkpoint in the
+     * same turn already has it waiting, or a queued message went straight out —
+     * the session never passes through idle then, so nothing flickers. The first
+     * turn of an attempt to end that way, cleanly, gets the completion reminder
+     * instead: weaker models often finish the work and report in prose.
+     */
+    private onTurnEnd;
+    subscribe(observer: OrchestratorObserver): () => void;
+    /**
+     * Isolated per observer: one that throws must not take down the scheduler
+     * or stop the remaining observers from hearing the event.
+     */
+    private emit;
+    get isRunning(): boolean;
+    /**
+     * A runner is executing *right now*. Narrower than {@link isRunning}, which
+     * also covers the armed-but-idle scheduler `tick()` deliberately leaves
+     * behind when a plan is paused on a user task, a checkpoint or a hold —
+     * nothing is executing then, so nothing is reading the plan mid-mutation.
+     */
+    get hasLiveWork(): boolean;
+    get isReviewApproved(): boolean;
+    /** The scheduler is driving the plan: ready tasks start on their own as slots free. Narrower than {@link isRunning}. */
+    get isScheduling(): boolean;
+    /**
+     * A full-plan run with nothing starting that something still resumes: a
+     * usage limit's reset, or a retry of a failed task its blocked tasks wait on.
+     */
+    get awaitsResume(): boolean;
+    get status(): 'approved' | 'running' | 'completed';
+    get activeTaskIds(): string[];
+    /** Task id → session id of every attempt whose runner is up; a spawn in flight has no session yet. */
+    get activeSessionMap(): Map<string, string>;
+    getAttempt(taskId: string): TaskAttemptSnapshot | undefined;
+    /** A planner turn holds new starts: what is ready starts when it releases them. */
+    get startsHeld(): boolean;
+    /**
+     * Hold the scheduler's new starts while a planner turn decides what runs
+     * next, so its edits do not race a task that would otherwise start under
+     * it. Running attempts are untouched. The release is idempotent and starts
+     * nothing itself: whoever releases ticks, which starts what became ready.
+     */
+    holdStarts(): () => void;
+    /**
+     * Admit a start that will wait before it claims — on the user's answer, a
+     * held edit, the run opening. Until it is released, Stop counts it as live
+     * work; once a Stop comes it is no longer current, and its claim is refused.
+     */
+    admitStart(): StartAdmission;
+    /**
+     * Something can still start that nobody has to ask for again: a start
+     * admitted and not yet claimed, or a task that resumes on its own at its
+     * usage limit's reset. A Stop is owed to it, whether or not anything runs.
+     */
+    get startsPending(): boolean;
+    /** Run `work`, which awaits before it claims, under an admission it holds throughout; it is handed the generation it was admitted under. */
+    private whileAdmitted;
+    /**
+     * "Merge all"; a settled run that merged everything is cleared up and
+     * forgotten. During a run it merges what has landed and the run goes on:
+     * the tasks waiting at a merge gate for that work then start (ADR-0020).
+     * Never alongside ops work, either way round ({@link mergeExcludes}).
+     */
+    mergeRun(): Promise<IsolationMergeResult>;
+    private mergeLanded;
+    /**
+     * Close the settled run. With merge at gates automatically on, landed work
+     * not merged yet is merged first, through the gate's path, so no surface
+     * hears of a handoff for a run about to merge; one that stopped is handed
+     * over as before.
+     */
+    private closeRun;
+    /**
+     * The run as a surface offers Merge all mid-run (ADR-0020): what has landed
+     * and is not merged, and whether the run is paused at its gates with nothing
+     * else running. Null once everything landed is merged.
+     */
+    runMergeView(): RunMergeView | null;
+    /**
+     * The ancestors an ops or user task waits on at its merge gate: those whose
+     * landed work is not in the user's branch yet (ADR-0020). Empty once the
+     * task has started, and for every other task.
+     */
+    getMergeGate(taskId: string): string[];
+    /** The failed tasks a task not started yet waits on, through its dependencies (ADR-0034); empty when it is not blocked. */
+    getBlockedBy(taskId: string): string[];
+    loadPlan(tasks: readonly Task[], planRunners?: RunnerId[]): void;
+    /**
+     * Adopt an edited plan without letting go of the run in progress. Everything
+     * the scheduler owns — live sessions, holds, retry counts, the verifier and
+     * the review approval — survives, because `loadPlan` clears all of it and a
+     * mid-run edit is not a new run. Only the tasks change.
+     *
+     * The ids with live sessions are defended: one dropped from the edited plan is
+     * carried over (its verdict still has to land somewhere), and one whose status
+     * the snapshot predates is put back to `in_progress` — adopting the snapshot's
+     * "pending" would offer the scheduler work a runner is already doing.
+     *
+     * A failed task stays failed, unlike a plan load's fresh chance: an edit is
+     * not a retry, and the tasks it blocks wait for that retry (ADR-0034).
+     */
+    reconcilePlan(newTasks: Task[], planRunners?: RunnerId[]): void;
+    start(origin?: RunOrigin): Promise<void>;
+    /** A usage-limit pause holds the run: spawning more would spend the same exhausted limit. */
+    private holdOnLimit;
+    /**
+     * Stop the run. The user's Stop also withdraws every start admitted before
+     * it and not yet claimed (ADR-0029); a `restart` only disarms an idle
+     * scheduler for the run about to start, which must not undo starts asked
+     * for meanwhile.
+     */
+    stop(reason?: 'user' | 'restart'): void;
+    /** Name the tasks a stop took down, so none is mistaken for one still at work. */
+    private sayStopped;
+    /**
+     * A task in progress with no attempt has nothing running it: a stop, a plan
+     * load or anything else that ended its attempt left its status behind. It
+     * is put back to not started, and said, so it can be retried rather than
+     * read as running — or, in an isolated run, count as live work forever.
+     */
+    private recoverOrphans;
+    /**
+     * Task ids still live, whose worktrees no clean-up of the whole run may
+     * take: an attempt is running them, or the plan has them in progress or
+     * waiting on the user mid-attempt — at a checkpoint, or for input. One
+     * waiting on the user's decision instead (a conflict, a usage limit, files
+     * an ops task changed) is not: no runner is at work on it, and a clean-up
+     * keeps what it holds on a branch before its worktree goes.
+     */
+    private liveTaskIds;
+    /**
+     * Whether the run may close with its handoff: no task is live. A handoff
+     * tells the user the run has finished, and a Merge all after it clears the
+     * run up, so neither may happen under a task the plan still shows at work.
+     */
+    private get settled();
+    /**
+     * The boundary a verdict crosses: nothing awaits the verifier's listener, so
+     * a throw from reading the output, landing, releasing a worktree or the tick
+     * after would be an unhandled rejection — and an attempt left integrating is
+     * live work forever. One that never settled fails (a repair waits on the
+     * user, as its conflict did) and blocks only its dependents; either way the
+     * run says why and goes on.
+     */
+    private deliverVerdict;
+    /** Work nothing awaits: a rejection is said, not left unhandled. */
+    private unawaited;
+    private onVerdict;
+    private afterVerdict;
+    /**
+     * A repair's verdict never replaces the verdict the task's own work earned,
+     * and a repair that does not land leaves the task waiting on the user —
+     * never a failed task, so never one that blocks its dependents.
+     */
+    private settleRepair;
+    /**
+     * Hand an attempt's verdict to Landing. The attempt stays live while that
+     * settles — it may wait on the module's merge queue — so a cancel, retry or
+     * stop in that window still wins, and waits for the merge before tearing the
+     * worktree down; nothing counts the task as done before its work is on the
+     * integration branch.
+     */
+    private land;
+    /** Settle a task by how its landing went; `onLanded` is what the path that landed it adds to completing it. */
+    private applyLanding;
+    /**
+     * Work that did not land waits on the user — it never fails the task or
+     * blocks its dependents — unless its conflict is owed a repair, which takes
+     * the slot the ending attempt freed and never one more than the run allows.
+     */
+    private settleUnlanded;
+    private landResolved;
+    getReadyTasks(): Task[];
+    private readiness;
+    private mergesAutomatically;
+    /**
+     * The user changed the run settings under an open run (ADR-0030). The
+     * scheduler reads them at each decision it makes from them, so a merge gate
+     * already reached is merged now rather than at the next event. Fire-and-forget
+     * — no caller waits on the change — and its failure is said through
+     * {@link unawaited}, never left unhandled.
+     */
+    runSettingsChanged(): void;
+    private openRun;
+    /**
+     * Open the run a task starts in, and decide whether it isolates if the
+     * task's next attempt needs that ({@link decidesIsolation}). False while a
+     * dirty tree waits on the user; `resume` is what their choice replays.
+     */
+    private openFor;
+    /**
+     * {@link openFor} for an explicit start admitted at `admittedAt`. A Stop
+     * while the run opened interrupts that opening too, which then opens
+     * nothing; the start says it was stopped rather than going quiet as if a
+     * dirty tree were waiting on the user.
+     */
+    private openForAdmitted;
+    /** The kind a task's next attempt starts as, short of a repair or a continue: what is weighed before one exists. */
+    private nextAttemptKind;
+    /**
+     * 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
+     * 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 runClaimed} 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.
+     */
+    releaseTask(taskId: string): Promise<void>;
+    markTaskComplete(taskId: string): Promise<void>;
+    /**
+     * Undo a completion: return the task to "not executed" — pending, verdict and
+     * summary dropped, archive entry removed. It is put on hold like a cancel, so
+     * a running plan does not immediately re-spawn the work the user just
+     * un-marked; Retry / Force Start / Run release the hold. Dependents fall back
+     * to waiting on their own, because the scheduler gates on `isCompleted`.
+     */
+    markTaskIncomplete(taskId: string): Promise<void>;
+    /**
+     * Skip: end a task as `skipped`, with no verdict and nothing of its work
+     * landed. Its worktree is kept, as a failed attempt's is, so the user can
+     * still look at it or Mark complete it later. Its dependents go ahead
+     * without it once the work it waited on is done, and a run that ended on a
+     * failure continues for them, as a retry would continue it. A running task is stopped before it is skipped.
+     */
+    skipTask(taskId: string, reason?: string, origin?: RunOrigin): Promise<void>;
+    private logAndArchive;
+    retryTask(taskId: string, origin?: RunOrigin): Promise<void>;
+    /**
+     * Continue a finished structured task in its saved runner session (ADR-0018,
+     * K1): a retry whose first turn is the user's message, sent to the session
+     * the task ended in rather than a fresh one given its prompt again. The
+     * worktree keeps the same path, where the runner keeps its sessions, and
+     * restores the previous work so that session's memory matches its files.
+     */
+    continueTask(taskId: string, message: string, origin?: RunOrigin): Promise<void>;
+    /**
+     * Keep a task paused on its runner's usage limit from resuming on its own:
+     * it waits for a manual retry, as one whose reset time could not be read
+     * does. What a surface's cancel calls, and what moving the task to another
+     * runner has to call first. False when no resume was scheduled for it.
+     */
+    cancelScheduledResume(taskId: string): boolean;
+    /**
+     * Run before writing assignments so cancellation sees the old runner's
+     * shared wait. A session cannot cross runners, so the next attempt is a
+     * carry-over of the paused attempt's files (ADR-0018, U1).
+     */
+    releaseMovedResume(taskId: string, changes: Partial<Task>): Partial<Task>;
+    /**
+     * A task's attempt stopped on its runner's usage limit, without a
+     * completion call. Failing would paint a red X on a task that only has to
+     * wait, and spawning more tasks would spend the same exhausted limit, so the
+     * task pauses and the run holds. When the runner said when its limit
+     * resets, the task joins its runner's wait and resumes on its own then
+     * (#84); otherwise, or when it was resumed a moment ago and hit the limit
+     * again, it waits for the user to retry it.
+     */
+    private pauseOnLimit;
+    /**
+     * The limit arrived as the turn's error with the runner still up: the
+     * attempt ends here, as its verdict would have ended it, so a resume is a
+     * continue in a fresh process (ADR-0018, L1/K1).
+     */
+    private stopOnLimit;
+    /** The tasks waiting on `runner`'s reset to resume on their own. */
+    private waitingOn;
+    /**
+     * Arm `runner`'s one wait for the latest resume time among its tasks, and
+     * put that time on each of them, so they resume together.
+     */
+    private armLimitWait;
+    /**
+     * The waits a loaded plan still owes. A resume time that passed while
+     * nothing was running — the daemon was down, say — resumes at once.
+     */
+    private rearmLimitWaits;
+    /**
+     * Resume a task paused on its runner's usage limit now, in its saved
+     * session, once the user says the limit has reset early. The limit is the
+     * runner's account's, so every task waiting on that runner's reset resumes
+     * with it, as at the reset itself. `message` follows the reset notice in the
+     * same continuation. A resumed attempt that hits the limit again at once
+     * waits for the user, as an automatic resume's does: that is what keeps a
+     * caller from resuming it round and round.
+     */
+    resumeNow(taskId: string, origin?: RunOrigin, message?: string): Promise<void>;
+    private resumeAfterLimit;
+    /**
+     * Retry a task paused on a usage limit, continuing its saved session where
+     * it left one (ADR-0018, K1), then release the hold the pause put on the
+     * run once nothing else waits on a reset.
+     */
+    private resumeTask;
+    /**
+     * A resume at the limit's reset that nobody waits on cannot be refused to
+     * anyone, so one that may not claim waits for the user instead — its resume
+     * time dropped, and said — unless a Stop is why, which said so itself.
+     */
+    private mayResumeAtReset;
+    /**
+     * Manually start a single AI task right now, bypassing dependency/readiness
+     * gating (the "force start" affordance on a task card) but never the claim:
+     * it still needs the user's approval, a free slot, and no Stop since it was
+     * asked for, and throws {@link TaskControlError} saying which it lacks.
+     * Reuses the scheduler's own claim so a force-started task gets the same
+     * augmented prompt, session tracking, and exit handling — callers must not
+     * re-spawn the runner themselves. No-op if the task is unknown, not an AI
+     * task, or already running.
+     */
+    forceStartTask(taskId: string, origin?: RunOrigin): Promise<void>;
+    private refuseOpsDuringMerge;
+    /**
+     * A force start passes a merge gate (ADR-0020), and the surface confirmed it
+     * first; the choice is kept on the task and said, because the work it acts
+     * on is not in the user's branch.
+     */
+    private notePastGate;
+    /**
+     * Run exactly one task outside full-plan scheduling. The active/starting
+     * 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;
+    getTotalCount(): number;
+    isAllComplete(): boolean;
+    isAnyFailed(): boolean;
+    approveReview(origin?: RunOrigin): Promise<void>;
+    tick(): Promise<void>;
+    /** How a run that ended on failures ends: what it finished, what failed, and what that blocks. */
+    /** Skipped work is not completed work, so a run with any says so rather than that everything completed. */
+    private sayFinished;
+    private sayEndedOnFailure;
+    /** Whether the scheduler may start `id` now: it passes every readiness gate and a slot is free. */
+    private stillReady;
+    /**
+     * A run paused at merge gates says so, as plainly as a task that waits on
+     * the user: which tasks wait, and that Merge all lets them go on (ADR-0020).
+     */
+    private sayGate;
+    /**
+     * Why a start may not take its claim now, or null when it may: a Stop came
+     * since it was admitted (ADR-0029), the task is outside the user's approval
+     * record (ADR-0035), or every slot is taken. Read in the same synchronous
+     * step as the claim it guards, so nothing can change in between.
+     */
+    private claimRefusal;
+    /** An explicit start's refusal, before it changes anything: its caller's answer, as a {@link TaskControlError}. */
+    private refuseClaim;
+    /** An explicit start's claim, once {@link refuseClaim} let it through: its spawn, or the refusal as a rejection. */
+    private claimed;
+    /**
+     * The one claim every attempt start passes — the scheduler's, a run or force
+     * start, a retry's, a continue, a resume, a repair. Checked and taken in one
+     * synchronous step ({@link claimRefusal}), then marked claimed before
+     * anything is awaited, so no other start can take the same task or slot.
+     * A task already claimed is not claimed again: there is nothing to start.
+     */
+    private claim;
+    private runClaimed;
+    /**
+     * The fallible half of starting a task: resolving its cwd/worktree and
+     * spawning the runner. Resolves false when the attempt never committed —
+     * abandoned because it was ended from under it, or a failed spawn already
+     * unwound (both leave `runClaimed` with nothing further to announce).
+     */
+    private spawnAttempt;
+    /** For a skill the main checkout has, the folder a worktree only gets once it is committed. */
+    private uncommittedSkillFolder;
+    /**
+     * The roots whose `.ordewell/skills/` an attempt at `cwd` reads: in a repo
+     * group, `cwd` holds each repo — a worktree of it when isolated, the
+     * workspace's own checkout when not — and no folder of its own (ADR-0014).
+     */
+    private skillRoots;
+    /**
+     * A continue whose runner never announced the session it was told to
+     * resume. Nothing was continued, and nothing fresh was started in its place.
+     */
+    private unresumed;
+    /**
+     * A spawn whose attempt ended while it was in flight: kill what it produced
+     * and take back the claim it made. Only the claim — whatever ended the
+     * attempt may have decided the task since (mark complete, cancel, retry).
+     */
+    private abandonSpawn;
+    private tell;
+    private say;
+    /**
+     * Replay the start a dirty tree turned away. `stash` puts the user's tracked
+     * changes on the git stash first, so the run isolates; `shared` runs this one
+     * run in the workspace root, knowingly.
+     */
+    continueBlockedRun(how: 'stash' | 'shared'): Promise<void>;
+    /**
+     * The one way an attempt ends. Dropping the record is itself what
+     * invalidates a spawn still in flight ({@link runClaimed} kills the session
+     * it receives for an attempt that is no longer current).
+     *
+     * A user interruption also bumps the verifier's generation *before* stopping
+     * the runner: a runner may fire onExit synchronously from
+     * stop(), and if that exit reaches VerdictEngine under the still-valid
+     * generation it delivers a verdict that marks the task 'completed' for one
+     * tick — long enough for the scheduler to start a dependent task. Stop and
+     * load reset the whole verifier themselves.
+     */
+    private endAttempt;
+    /** Kept on the task once the attempt ends, so a continue can resume it after a reload (ADR-0018, K1). */
+    private saveNativeSession;
+    private endAllAttempts;
+}
 
 /**
  * Task references: the one grammar for naming a task in a plan, both ways.
@@ -2143,7 +2274,7 @@ declare class RunSettingsError extends Error {
 }
 interface UserSettings {
     modelAllowlist?: Record<string, string[]>;
-    /** Last model (and its thinking effort) the user chose for each planner backend, keyed by AiProvider id. */
+    /** Last model (and its thinking effort) the user chose for each planner backend, keyed by planner backend id. */
     plannerModels?: Record<string, {
         model: string;
         effort?: string;
@@ -2457,6 +2588,18 @@ interface ConversationView extends BlockList {
     }[];
 }
 declare const EMPTY_CONVERSATION: ConversationView;
+type Message<T extends SessionMessage['type']> = Extract<SessionMessage, {
+    type: T;
+}>;
+/**
+ * Bring the view's approval cards in line with the planner's requests the
+ * session says are still waiting — for a surface that was not listening the
+ * whole time: one that reconnected, reloaded, or just attached. A pending card
+ * the session no longer has was answered or expired meanwhile; this surface
+ * never heard how, so the card goes rather than guessing an answer. A waiting
+ * request with no card gets one, answerable as the live one would have been.
+ */
+declare function reconcileApprovals(view: ConversationView, waiting: readonly Message<'approval_request'>[]): ConversationView;
 /**
  * Fold one input into the view. Pure and incremental: blocks the input does
  * not touch keep their identity, and an input that changes nothing returns
@@ -2640,6 +2783,29 @@ declare function skillTokens(text: string): SkillToken[];
 /** The tokens in a sent message that loaded one of `loaded` — what a surface highlights in the user's bubble. */
 declare function loadedSkillTokens(text: string, loaded: readonly string[]): SkillToken[];
 
+/**
+ * One markdown-it token, as far as a surface reads it. Declared here rather
+ * than re-exporting markdown-it's class so a surface depends on core alone.
+ */
+interface MarkdownToken {
+    readonly type: string;
+    readonly tag: string;
+    readonly nesting: 1 | 0 | -1;
+    readonly level: number;
+    readonly content: string;
+    readonly markup: string;
+    readonly info: string;
+    readonly block: boolean;
+    readonly hidden: boolean;
+    readonly map: readonly [number, number] | null;
+    readonly attrs: readonly (readonly [string, string])[] | null;
+    readonly children: readonly MarkdownToken[] | null;
+}
+/** The parsed blocks of a model's text, for a surface that paints them itself (the TUI). */
+declare function markdownTokens(text: string): readonly MarkdownToken[];
+/** A model's text as HTML, safe to set as a webview element's innerHTML. */
+declare function markdownHtml(text: string): string;
+
 /**
  * What a row's status means to a reader, before any surface picks a word,
  * icon or colour for it. `quiet` is a running task whose runner has printed
@@ -2666,6 +2832,12 @@ declare function awaitingLabel(task: {
 declare function blockedByLabel(refs: readonly string[]): string;
 /** "Skipped: no GPU on this host", or "Skipped" when no reason was given. */
 declare function skippedLabel(reason: string | null): string;
+/**
+ * A task added after the user approved the plan, which the scheduler leaves
+ * for them (ADR-0035). Not a runner approval: nothing has started, so no
+ * runner is asking anything.
+ */
+declare const WAITS_FOR_APPROVAL_LABEL = "Waiting for your approval to start";
 /** Runner requests a task waits on (ADR-0018, A1); null when none do. */
 declare function approvalLabel(count: number | undefined): string | null;
 /**
@@ -2736,6 +2908,8 @@ interface TaskRowSubject {
     /** Its last attempt left a runner session to continue (ADR-0018, K1). */
     continuable?: boolean;
     awaitingApproval?: number;
+    /** Added after the user approved the plan, and not approved since (ADR-0035). */
+    waitsForApproval?: boolean;
     isolation?: TaskRowIsolation | null;
     mergeGate?: readonly string[];
     forcedPastGate?: readonly string[];
@@ -2802,6 +2976,8 @@ interface TaskRowView {
     resumes: string | null;
     /** Runner requests waiting on the user, in sentence case; null when none do. */
     approvals: string | null;
+    /** That it waits for the user's approval to start, in sentence case; null once it started, or when it needs none. */
+    waitsForApproval: string | null;
     /** The task's mode is tagged autonomous: it runs without permission prompts. */
     autonomous: boolean;
     /** The repos its isolated work changed, by path; empty for a group of one. */
@@ -2824,7 +3000,7 @@ interface TaskRowView {
         files: string;
         landed: boolean;
     } | null;
-    /** The dependencies, by reference, whose work is not merged into the user's branch yet. */
+    /** The ancestors, by reference, whose work is not merged into the user's branch yet. */
     mergeGate: string[] | null;
     /** The failed tasks, by reference, a task not started waits on through its dependencies (ADR-0034); null when none. */
     blockedBy: string[] | null;
@@ -2832,7 +3008,7 @@ interface TaskRowView {
     skipReason: string | null;
     /** An ops task changed tracked files in the user's checkout and nothing was committed. */
     opsChangedFiles: boolean;
-    /** The dependencies, by title, a force start went past the merge gate of. */
+    /** The ancestors, by title, a force start went past the merge gate of. */
     forcedPastGate: readonly string[] | null;
     /** The task's dependencies, by reference. */
     dependencies: string[];
@@ -2899,4 +3075,4 @@ declare function parseSwitch(arg: string): boolean | null;
 /** A whole number at least `min`, as typed; null for anything else. */
 declare function parseCount(arg: string | undefined, min: number): number | null;
 
-export { type RunnerLoadedBlock as $, ACT_RISK as A, type BlockingSubject as B, CHECKPOINT_TRUNCATE_LENGTH as C, type DiffRow as D, EMPTY_CONVERSATION as E, type NotificationAction as F, type GatedConversation as G, type OutputPreview as H, type INotification as I, type PlanMarkerStatus as J, type PlanSnapshot as K, type LiveTail as L, type MessageBlock as M, NOT_STARTED as N, type OrchestratorObserver as O, type PlanBlock as P, PlanStore as Q, type PlannerModes as R, type PromptHold as S, RUN_SETTINGS_DEFAULTS as T, type RefTask as U, type RunInput as V, type RunMergeView as W, RunSettingsError as X, type RunTask as Y, type RunTaskStatus as Z, type RunView as _, AUTORUN_RISK as a, diffRows as a$, SUPERVISOR_LEVEL_LABEL as a0, type SerializedConversationMessage as a1, type SerializedPendingTurn as a2, type SerializedPlan as a3, type SerializedTask as a4, type SerializedTaskStatus as a5, type SessionBroadcaster as a6, type SessionMessage as a7, type SessionNotice as a8, SettingsService as a9, type TaskRowUsage as aA, type TaskRowView as aB, type TaskStatusKind as aC, type ThinkingDisplayBlock as aD, type ToolBlock as aE, type ToolHeadline as aF, type ToolStatus as aG, type TurnGate as aH, type UsageBlock as aI, type UserSettings as aJ, aheadOfDraft as aK, applyTaskOps as aL, approvalLabel as aM, automergeSummary as aN, autorunSummary as aO, awaitingLabel as aP, blockedByLabel as aQ, blockingFailures as aR, canMergeTasks as aS, canSetDependencies as aT, canSplitTask as aU, capConflictFiles as aV, classifyOutcome as aW, coalesceTaskLog as aX, dependencyCandidates as aY, dependentsNotice as aZ, dependentsOf as a_, type SkillLoadBlock as aa, type SkillLookup as ab, type SkillToken as ac, type SubagentBlock as ad, type SubagentChild as ae, type SubagentStatus as af, type SurfacePlan as ag, type SurfacePlanState as ah, type SurfaceTask as ai, type TakenPrompt as aj, type TaskAttemptSnapshot as ak, TaskControlError as al, type TaskLogEvent as am, type TaskLogView as an, type TaskOp as ao, TaskOrchestrator as ap, type TaskOrchestratorDeps as aq, type TaskOrchestratorOptions as ar, type TaskOutputSource as as, type TaskRef as at, type TaskRowAction as au, type TaskRowContext as av, type TaskRowIsolation as aw, type TaskRowKind as ax, type TaskRowPlacement as ay, type TaskRowSubject as az, type ApplyTaskOpsResult as b, diffStat as b0, diffSummary as b1, digestTaskLog as b2, drainNext as b3, executionSummary as b4, followTurn as b5, fromTranscript as b6, getSettingsPath as b7, hasHiddenDetail as b8, holdPrompt as b9, skippedLabel as bA, stopTurn as bB, summarizeToolCall as bC, supervisorSummary as bD, surfacePlan as bE, surfacePlanState as bF, takeAt as bG, taskLogForSurface as bH, taskOrderLabel as bI, taskRef as bJ, taskRefOf as bK, taskRowActions as bL, taskRowView as bM, taskStartedNotice as bN, taskStatusKind as bO, textHasTaskOps as bP, titledRefs as bQ, titledTaskRef as bR, titledTaskRefOf as bS, toTaskLogEvent as bT, toolHeadline as bU, trimToolOutput as bV, truncateCheckpointSummary as bW, unsendAll as bX, unsendLatest as bY, isTaskRunning as ba, loadedSkillTokens as bb, markAction as bc, markRequestFor as bd, namedRepos as be, newTaskFields as bf, opsEditable as bg, outputLines as bh, outputPreview as bi, parseCount as bj, parseSwitch as bk, parseTaskOpsJson as bl, pastGateConfirmation as bm, reduceConversation as bn, reduceRun as bo, reduceTaskLog as bp, replayTaskLog as bq, resolveTaskRef as br, resumeLabel as bs, resumeTime as bt, runSettingsOf as bu, runnerToolSubject as bv, serializePlan as bw, serializeTask as bx, serializeTaskStatus as by, skillTokens as bz, type ApprovalBlock as c, type ApprovalStatus as d, type AutoMergeTrigger as e, type CommandBlock as f, type CommandStatus as g, type CompactionBlock as h, type ConversationInput as i, type ConversationView as j, type DiffRowKind as k, type DiffStat as l, type DisplayBlock as m, EMPTY_HOLD as n, EMPTY_RUN as o, EMPTY_TASK_LOG as p, type EditCatalog as q, type ExecutionSummary as r, type GlobalRunSettings as s, type IsolatedExecution as t, IsolationRunController as u, type LiveTailOptions as v, type LocalEntry as w, type MessageRole as x, NO_TURN as y, type NewTaskFields as z };
+export { type RunTask as $, ACT_RISK as A, type BlockingSubject as B, CHECKPOINT_TRUNCATE_LENGTH as C, type DiffRow as D, EMPTY_CONVERSATION as E, NO_TURN as F, type GatedConversation as G, type HeldEdit as H, type INotification as I, type NewTaskFields as J, type NotificationAction as K, type LiveTail as L, type MarkdownToken as M, NOT_STARTED as N, type OrchestratorObserver as O, type OutputPreview as P, type PlanBlock as Q, type PlanMarkerStatus as R, type PlanSnapshot as S, PlanStore as T, type PlannerModes as U, type PromptHold as V, RUN_SETTINGS_DEFAULTS as W, type RefTask as X, type RunInput as Y, type RunMergeView as Z, RunSettingsError as _, AUTORUN_RISK as a, capConflictFiles as a$, type RunTaskStatus as a0, type RunView as a1, type RunnerLoadedBlock as a2, STOPPED_BEFORE_START as a3, SUPERVISOR_LEVEL_LABEL as a4, type SerializedConversationMessage as a5, type SerializedPendingTurn as a6, type SerializedPlan as a7, type SerializedTask as a8, type SerializedTaskStatus as a9, type TaskRowContext as aA, type TaskRowIsolation as aB, type TaskRowKind as aC, type TaskRowPlacement as aD, type TaskRowSubject as aE, type TaskRowUsage as aF, type TaskRowView as aG, type TaskStatusKind as aH, type ThinkingDisplayBlock as aI, type ToolBlock as aJ, type ToolHeadline as aK, type ToolStatus as aL, type TurnGate as aM, type UsageBlock as aN, type UserSettings as aO, WAITS_FOR_APPROVAL_LABEL as aP, aheadOfDraft as aQ, applyTaskOps as aR, approvalLabel as aS, automergeSummary as aT, autorunSummary as aU, awaitingLabel as aV, blockedByLabel as aW, blockingFailures as aX, canMergeTasks as aY, canSetDependencies as aZ, canSplitTask as a_, type SessionBroadcaster as aa, type SessionMessage as ab, type SessionNotice as ac, SettingsService as ad, type SkillLoadBlock as ae, type SkillLookup as af, type SkillToken as ag, type StartAdmission as ah, type SubagentBlock as ai, type SubagentChild as aj, type SubagentStatus as ak, type SurfacePlan as al, type SurfacePlanState as am, type SurfaceTask as an, type TakenPrompt as ao, type TaskAttemptSnapshot as ap, TaskControlError as aq, type TaskLogEvent as ar, type TaskLogView as as, type TaskOp as at, TaskOrchestrator as au, type TaskOrchestratorDeps as av, type TaskOrchestratorOptions as aw, type TaskOutputSource as ax, type TaskRef as ay, type TaskRowAction as az, type ApplyTaskOpsResult as b, titledTaskRefOf as b$, classifyOutcome as b0, coalesceTaskLog as b1, dependencyCandidates as b2, dependentsNotice as b3, dependentsOf as b4, diffRows as b5, diffStat as b6, diffSummary as b7, digestTaskLog as b8, drainNext as b9, resolveTaskRef as bA, resumeLabel as bB, resumeTime as bC, runSettingsOf as bD, runnerToolSubject as bE, serializePlan as bF, serializeTask as bG, serializeTaskStatus as bH, skillTokens as bI, skippedLabel as bJ, stopTurn as bK, summarizeToolCall as bL, supervisorSummary as bM, surfacePlan as bN, surfacePlanState as bO, takeAt as bP, taskLogForSurface as bQ, taskOrderLabel as bR, taskRef as bS, taskRefOf as bT, taskRowActions as bU, taskRowView as bV, taskStartedNotice as bW, taskStatusKind as bX, textHasTaskOps as bY, titledRefs as bZ, titledTaskRef as b_, executionSummary as ba, followTurn as bb, fromTranscript as bc, getSettingsPath as bd, hasHiddenDetail as be, holdPrompt as bf, isTaskRunning as bg, loadedSkillTokens as bh, markAction as bi, markRequestFor as bj, markdownHtml as bk, markdownTokens as bl, namedRepos as bm, newTaskFields as bn, opsEditable as bo, outputLines as bp, outputPreview as bq, parseCount as br, parseSwitch as bs, parseTaskOpsJson as bt, pastGateConfirmation as bu, reconcileApprovals as bv, reduceConversation as bw, reduceRun as bx, reduceTaskLog as by, replayTaskLog as bz, type ApprovalBlock as c, toTaskLogEvent as c0, toolHeadline as c1, trimToolOutput as c2, truncateCheckpointSummary as c3, unsendAll as c4, unsendLatest as c5, type ApprovalStatus as d, type AutoMergeTrigger as e, type CommandBlock as f, type CommandStatus as g, type CompactionBlock as h, type ConversationInput as i, type ConversationView as j, type DiffRowKind as k, type DiffStat as l, type DisplayBlock as m, EMPTY_HOLD as n, EMPTY_RUN as o, EMPTY_TASK_LOG as p, type EditCatalog as q, type ExecutionSummary as r, type GlobalRunSettings as s, type HeldEditMark as t, type IsolatedExecution as u, IsolationRunController as v, type LiveTailOptions as w, type LocalEntry as x, type MessageBlock as y, type MessageRole as z };