@ordewell/core 0.12.0 → 0.12.1

package/dist/{runSettingsText-CvZ40IPv.d.ts → runSettingsText-lKLDsyli.d.ts}

@@ -1,18 +1,234 @@
-import { a_ as StoredHandoff, b1 as Task, aK as RunnerId, bb as TaskSnapshot, b as AwaitingReason, bh as UsageRecord, aL as RunnerSessionCost, i as DiscoveredModel, aZ as SkillsService, aU as SkillInfo, az as RepoGroupLayout, z as IWorktreeIsolation, a0 as IsolationRun, M as IsolationHandoff, af as PlanIsolation, a1 as IsolationTaskRecord, b4 as TaskIsolation, a5 as IsolationView, ao as PrepareIntent, as as PreviousWork, q as HandoffCommit, U as IsolationOutcome, aw as RepairEvidence, bf as TreeSnapshot, b2 as TaskDiffRead, b3 as TaskDiffResult, T as IsolationMergeResult, a7 as LandedWork, aI as RevertWatch, _ as IsolationRevertResult, bj as Verdict, a8 as LegacyPlanState, b8 as TaskReportTo, ba as TaskSkillSnapshot, b9 as TaskSkillNotice, a$ as SubagentOutcome, a2 as IsolationTaskRef, aH as RevertCommand, $ as IsolationRevertTask, d as ConversationMessage, aW as SkillLoadNotice, ae as PendingPlanTurn, r as HandoffDigest, a as AttemptUsage, b6 as TaskLoop, aJ as RunSettings, ai as PlanUsage, ay as ReplyRun, aP as SessionBilling, ab as ModelUsage, bi as UsageTotals, c as ContextFill, aj as PlannerCompaction, k as ExecutionRecord, aE as ResearchStep, ag as PlanState, ax as RepairWait, b0 as SupervisorLevel, bc as TaskStatus, E as ExecutionActor, l as GuardTrip, G as GuardTarget, j as ExecutionCommandName, aD as ResearchProgress, aC as ResearchLogEntry, aV as SkillLoad, al as PlannerContextPause, ah as PlanStatus, R as IsolationMergeBlock, P as IsolationLandedTask, V as IsolationPreview, aG as ResearchToolType, a9 as LoopSubject, aF as ResearchStepOutcome, ak as PlannerCompactionOutcome, an as PlannerUsage, F as FindingSeverity, bd as TaskType, ad as PatchView, b5 as TaskIsolationState, be as TaskUsageSummary } from './Task-BTEH-ztX.js';
-import { q as ApprovalRequest, r as ApprovalSource, N as IApproval, bs as ToolOutcome, R as IRunnerSession, O as IConfig, bt as UsageLimitSignal, be as TaskMessageFrom, aN as RunnerModelRef, aE as RunnerCommand, aK as RunnerMcpServer, b6 as StructuredTurnEnd, k as ApprovalDecision, aZ as ScriptRun, a_ as ScriptStatus, b5 as StructuredEvent, j as ApprovalAnswer, ar as QueuedTaskMessage, l as ApprovalKind, Q as IRunner, aO as RunnerRegistry, bn as TaskShellSite, bm as TaskShell, az as RuleWord, af as PlannerAllowlist, aW as ScriptBody, d as AgentProcessDeps, a as AgentAdapter, a9 as OrdewellMcpServer, P as IFileSystem, am as PlannerToolHandler, aJ as RunnerManifest, bk as TaskRunnerConfig, f as AiProvider, ag as PlannerBackendId, a8 as OrchestratorOption } from './IRunner-DjJkYwko.js';
-import { R as RunnerModeInfo } from './ModeResolver-CHsaoV7M.js';
+import { b3 as RunnerId, bp as Task, p as DiscoveredModel, bl as StoredHandoff, bA as TaskSnapshot, b as AwaitingReason, bG as UsageRecord, b4 as RunnerSessionCost, J as HandoffCommit, bI as Verdict, aj as LegacyPlanState, bx as TaskReportTo, bz as TaskSkillSnapshot, by as TaskSkillNotice, bm as SubagentOutcome, c as BelowPlan, C as CheckWord, am as Mandate, aq as MandateRequest, ap as MandateRefusal, ad as IsolationTaskRef, a$ as RevertCommand, aa as IsolationRevertTask, h as ConversationMessage, bh as SkillLoadNotice, aw as PendingPlanTurn, K as HandoffDigest, a as AttemptUsage, bv as TaskLoop, bt as TaskIsolation, o as DelegatedRow, b2 as RunSettings, X as IsolationHandoff, aA as PlanUsage, a2 as IsolationMergeResult, aR as ReplyRun, ba as SessionBilling, ar as ModelUsage, bH as UsageTotals, g as ContextFill, aC as PlannerCompaction, s as ExecutionRecord, aY as ResearchStep, ay as PlanState, ab as IsolationRun, T as IWorktreeIsolation, aQ as RepairWait, ag as IsolationView, a9 as IsolationRevertResult, bB as TaskStatus, q as ExecutionActor, w as GuardTrip, at as NodeAuthority, v as GuardTarget, b7 as ScriptBody, r as ExecutionCommandName, aX as ResearchProgress, aW as ResearchLogEntry, bf as SkillInfo, bg as SkillLoad, bk as SkillsService, aE as PlannerContextPause, a0 as IsolationMergeBlock, _ as IsolationLandedTask, a4 as IsolationPreview, a_ as ResearchToolType, bo as SupervisorLevel, ak as LoopSubject, aZ as ResearchStepOutcome, aD as PlannerCompactionOutcome, aG as PlannerUsage, t as FindingSeverity, bC as TaskType, bn as SubtreeReport, av as PatchView, bu as TaskIsolationState, bD as TaskUsageSummary } from './Task-CxGgN6I0.js';
+import { q as ApprovalRequest, r as ApprovalSource, U as IApproval, bO as ToolOutcome, _ as IRunnerSession, a1 as IsolationRunController, V as IConfig, bR as UsageLimitSignal, bA as TaskMessageFrom, b4 as RunnerModelRef, aX as RunnerCommand, b1 as RunnerMcpServer, bs as StructuredTurnEnd, k as ApprovalDecision, bg as ScriptRun, bh as ScriptStatus, br as StructuredEvent, aj as NodePath, u as BoardDraft, v as BoardEntry, w as BoardPost, t as BoardAuthor, af as McpToolReply, J as EventStore, j as ApprovalAnswer, aK as QueuedTaskMessage, l as ApprovalKind, Y as INotification, Z as IRunner, b6 as RunnerRegistry, bo as SkillLookup, bJ as TaskShellSite, bI as TaskShell, K as ExecutionBackend, aR as ReservedLease, d as AgentProcessDeps, a as AgentAdapter, ar as OrdewellMcpServer, ap as OpenLease, W as IFileSystem, ay as PlannerModes, a0 as IsolatedExecution, aE as PlannerToolHandler, bG as TaskRunnerConfig, b0 as RunnerManifest, f as AiProvider, ax as PlannerBackendId, aq as OrchestratorOption, bl as SessionMeta } from './eventStore-CTCSKS9E.js';
+import { R as RunnerModeInfo } from './ModeResolver-B64aUZXJ.js';
 
-type NotificationAction = {
+/** What a planned task may be given: the runners it may run on and their modes. */
+interface IntakeCatalog {
+    runners: readonly RunnerId[];
+    /** Absent when no runner's modes are known: the mode is then guessed (ADR-0031). */
+    runnerModes?: Partial<Record<RunnerId, readonly RunnerModeInfo[]>>;
+    autonomousDefault?: boolean;
+    /**
+     * An edit's assignments are resolved against the catalog as it is planned,
+     * and a model it names that the runner does not offer is refused; a
+     * submitted plan's models are resolved as it lands instead (ADR-0003).
+     */
+    models?: AssignmentCatalog;
+    /**
+     * Why this planner may not write a delegated task or a read-only script
+     * (ADR-0055 D1, D8), or null when it may. Absent, there is no node to read:
+     * a one-shot planner, or a route that holds no mandate.
+     */
+    delegationRefusal?: string | null;
+    /** Which of a child's script tasks run sealed (ADR-0056 M9): each such lands read-only, on every route. */
+    sealsScripts?: (task: Pick<Task, 'commands' | 'script' | 'timeoutMs'>) => boolean;
+}
+
+/**
+ * Who writes a task's assignment. It decides what a model the writer names
+ * meets where the task's runner does not offer it or the allowlist excludes it
+ * (ADR-0003), which runners it may put a task on, and whether a live runner's
+ * hold applies (ADR-0041):
+ *
+ * - `plan`: a whole plan the planner submitted, and every planner task as it
+ *   lands. A stray model is replaced, and the planner is told what moved.
+ * - `edit`: the planner's edit. A stray model is refused, which the planner
+ *   answers in the same reply.
+ * - `user`: a user's direct edit. A stray model is refused, with the reason.
+ * - `userAdd`: a task the user adds. A stray model is replaced, and the user
+ *   is told what moved.
+ * - `runner`: a switch made with the runner's own `/model`, written as the
+ *   user's edit. The runner already runs it, so neither the allowlist nor the
+ *   live runner's hold applies.
+ */
+type AssignmentWriter = 'plan' | 'edit' | 'user' | 'userAdd' | 'runner';
+/**
+ * What an assignment is resolved against: the discovered models, the manifest
+ * modes and the allowlist, as the session holds them when the write lands —
+ * the same catalog the planner's per-turn block shows, so nothing is refused
+ * that the planner was never told about.
+ */
+interface AssignmentCatalog {
+    /** A runner absent, or listed with nothing, has models discovery could not find, not none. */
+    modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>;
+    /** Absent when no runner's modes are known: no mode is then derived. */
+    runnerModes?: Partial<Record<RunnerId, readonly RunnerModeInfo[]>>;
+    /** Raw (unfiltered) allowlist, keyed by runner; read through {@link effectiveAllowlist}. */
+    perRunnerAllowlist?: Partial<Record<RunnerId, string[]>>;
+    /** Why an edit may not write a delegated task, or null when it may; absent, no node is behind it (`IntakeCatalog`). */
+    delegationRefusal?: string | null;
+    /** Which script tasks an edit adds land sealed (`IntakeCatalog`). */
+    sealsScripts?: IntakeCatalog['sealsScripts'];
+    /** Full (true) or Guarded: the mode a derived task lands on unless it is read-only (ADR-0001). Full when absent. */
+    autonomousDefault?: boolean;
+    /**
+     * Whether a task's runner is live: an attempt of it is claimed, running,
+     * quiet or waiting on someone. Its model, effort and runner are then that
+     * runner's (ADR-0041): the process was started on them, and only the
+     * runner's own command moves them. Absent means none is.
+     */
+    liveRunner?: (taskId: string) => boolean;
+}
+/** What a runner offers a task, as discovery and its manifest have it. */
+interface RunnerCatalog {
+    models: DiscoveredModel[];
+    modes: RunnerModeInfo[];
+}
+/** A change the resolver made to what was written, named so it is never silent (ADR-0001). */
+interface AssignmentAdjustment {
+    taskId: string;
+    title: string;
+    field: 'assignedModel' | 'thinkingEffort';
+    from: string | null;
+    to: string | null;
+}
+
+/** Plan placement and dependency rules, shared with browser-bundled surfaces. */
+interface TreeTask<T> {
+    id: string;
+    order: number;
+    title: string;
+    subtasks?: readonly T[];
+}
+interface DependencyTask<T> extends TreeTask<T> {
+    dependencies: readonly string[];
+}
+interface TaskPlacement<T> {
+    task: T;
+    parent?: T;
+    ancestors: readonly T[];
+    siblings: readonly T[];
     label: string;
-    value: string;
+}
+declare function walkPlan<T extends TreeTask<T>>(tasks: readonly T[]): Generator<TaskPlacement<T>>;
+declare function taskPlacement<T extends TreeTask<T>>(tasks: readonly T[], id: string): TaskPlacement<T> | undefined;
+/** Includes the root: deletion has to detach every edge into the removed tree. */
+declare function subtreeIds<T extends TreeTask<T>>(tasks: readonly T[], id: string): Set<string>;
+/** Pickers offer earlier siblings; API validity is independent of display order. */
+declare function dependencyCandidates<T extends TreeTask<T>>(tasks: readonly T[], taskId?: string): T[];
+/** The surviving tasks whose dependency lists a subtree removal will change. */
+declare function dependentsOf<T extends DependencyTask<T>>(tasks: readonly T[], taskId: string): T[];
+interface DependencyCheck {
+    ok: boolean;
+    error?: string;
+}
+declare function canSetDependencies<T extends DependencyTask<T>>(tasks: readonly T[], taskId: string, dependencies: readonly string[]): DependencyCheck;
+
+/**
+ * Targeted task edits emitted by the planner conversation (the 'task_ops'
+ * ConversationTurn). Task references accept a task id, a "#<order>" ref, or a
+ * bare order number — cheap models rarely echo UUIDs correctly.
+ */
+/**
+ * A task as the planner writes it: its fields, less the mode, plus whether it
+ * must not change files (ADR-0031), and `thinkingEffort` as a name for its
+ * model's effort, so an effort can change without restating the model.
+ */
+type PlannerTaskSpec = Partial<Task> & {
+    readOnly?: boolean;
+    thinkingEffort?: string | null;
+};
+type TaskOp = {
+    op: 'update';
+    taskId: string;
+    changes: PlannerTaskSpec;
+} | {
+    op: 'add';
+    task: PlannerTaskSpec;
+    handle?: string;
+} | {
+    op: 'remove';
+    taskId: string;
+} | {
+    op: 'reorder';
+    taskIds: string[];
+} | {
+    op: 'merge';
+    taskIds: string[];
+    merged: PlannerTaskSpec;
+    handle?: string;
+} | {
+    op: 'split';
+    taskId: string;
+    parts: PlannerTaskSpec[];
+    handle?: string;
+} | {
+    op: 'rearm';
+    taskId: string;
+    changes?: PlannerTaskSpec;
 };
-interface INotification {
-    info(msg: string): void;
-    warn(msg: string): void;
-    error(msg: string): void;
-    confirm(msg: string, options: string[]): Promise<string | undefined>;
+declare function textHasTaskOps(text: string): boolean;
+/** Parse a `{"taskOps":[...]}` reply. Throws PlanParseError when the JSON is unusable. */
+declare function parseTaskOpsJson(text: string): TaskOp[];
+/** Which op of a batch a refusal is about: its number among the ops the call wrote, from 1. */
+interface OpRef {
+    number: number;
+    kind: string;
+}
+/** One reason a batch was refused, and the op it is about; absent for the batch as a whole, its order say. */
+interface OpRefusal {
+    op?: OpRef;
+    message: string;
+}
+/** A refusal as the planner reads it, its op named first. */
+declare function opRefusalText({ op, message }: OpRefusal): string;
+interface ApplyTaskOpsResult {
+    ok: boolean;
+    tasks: readonly Task[];
+    /** {@link refusals} as the planner reads them. */
+    errors: string[];
+    refusals: OpRefusal[];
+    /** Human-readable summary of what changed, for the chat transcript. */
+    summary: string[];
+    /** On ok, what the batch's tasks were adjusted to beyond what the planner wrote, as they stand at its end. */
+    adjustments?: AssignmentAdjustment[];
+    /** 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
+ * (rewiring every dependent of any selected task to the survivor) keep the
+ * dependency graph valid? Rejects locked tasks and merges whose rewiring would
+ * introduce a cycle. Display order is NOT checked here — neither
+ * consecutiveness (a UI concern) nor a dependency the merge pulls out of order,
+ * which {@link applyTaskOps} repairs; refusing on order would make this
+ * pre-flight stricter than the applier it stands in for.
+ */
+declare function canMergeTasks(tasks: readonly Task[], selectedIds: string[]): {
+    ok: boolean;
+    error?: string;
+};
+/**
+ * The shape the dependency helpers below read. Structural rather than `Task`,
+ * because the TUI projects tasks into its own `TaskView`: a surface's
+ * dependency picker and the API's validation must agree on which dependencies
+ * are legal, and a signature only core can satisfy would have forced the TUI
+ * to keep a second copy of the rule.
+ */
+interface TaskRef {
+    id: string;
+    order: number;
+    title: string;
+    dependencies: string[];
 }
 
+/** Pre-flight check for a split: the task exists and is not locked by execution. */
+declare function canSplitTask(tasks: readonly Task[], taskId: string): {
+    ok: boolean;
+    error?: string;
+};
+/**
+ * Apply task ops to a snapshot of the plan, atomically: either every op
+ * applies and the result validates (deps resolve, no cycles, running and
+ * completed tasks untouched), or nothing is returned and `errors` explains
+ * why. The caller commits `tasks` on ok.
+ *
+ * `earlierHandles` are the handles an earlier batch of the same planner turn
+ * gave, each with the id of the task it made (ADR-0022 P2): this batch may
+ * name those tasks by them, and may not give one of them again.
+ */
+declare function applyTaskOps(currentTasks: readonly Task[], ops: TaskOp[], runners: RunnerId[], catalog?: AssignmentCatalog, earlierHandles?: ReadonlyMap<string, string>): ApplyTaskOpsResult;
+
 /**
  * The SSRF guard for anything that leaves the machine on the planner's behalf.
  * An unguarded `http://169.254.169.254/` would hand a prompt-injected planner
@@ -289,692 +505,96 @@ declare class PlanStore {
      * `preserveCompleted: false` is for a freshly committed plan, where
      * everything starts over. `edited` is an edit adopted between runs, which is
      * not the user starting over: a failed task stays failed, and a task waiting
-     * on the user, whatever for, stays waiting. `keepFailed` is what failed in
-     * the reply autorun's run follows: nobody asked for those to run again.
-     */
-    resetForRun(opts?: {
-        preserveCompleted?: boolean;
-        edited?: boolean;
-        keepFailed?: ReadonlySet<string>;
-    }): void;
-    /**
-     * Execute's fresh chance with work already live (ADR-0053), which
-     * `resetForRun` would take back: only what failed and is not at work is
-     * readied, and a check between rounds still leaves its body to run first.
-     */
-    readyFailed(live: (taskId: string) => boolean): void;
-    /** See {@link releaseMadeManual}; `live` names what a runner still holds. */
-    releaseMadeManual(live?: (taskId: string) => boolean): void;
-    private ready;
-    markCompleted(id: string): void;
-    markFailed(id: string): void;
-    markSkipped(id: string, reason?: string): void;
-    markInProgress(id: string): void;
-    /** Its first attempt is starting: from now on its chat exists, whatever becomes of the attempt. */
-    markAttempted(id: string): void;
-    /** Its attempt starts: the number now tells its waits from the last attempt's, so they count from nothing (ADR-0053). */
-    markAttemptStarted(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;
-    /**
-     * A new attempt of the task, from nothing it earned. A loop's check starts
-     * its rounds over (ADR-0045 L7), unless `sameRound`: a resume after a usage
-     * limit goes on with the attempt the limit cut short.
-     */
-    retry(id: string, opts?: {
-        sameRound?: boolean;
-    }): void;
-    /** Its landed work was reverted (ADR-0054): as a retry leaves it, marked so until it starts. */
-    markReverted(id: string): void;
-    /** A loop's check counts its rounds afresh from its next run (ADR-0045 L7). */
-    startRoundsOver(id: string): void;
-    /**
-     * The loop runs its check again, as its next round (ADR-0045 L5): a new
-     * attempt, the round counted on, and nothing of the round before kept on
-     * the task — its report went to the body, and stays in its attempt's log.
-     */
-    repeat(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;
-    /** One of the task's waits is over, so what it waits on next is another (ADR-0053). */
-    endWait(id: string): void;
-    /** Work under way is the one status nobody could be waiting on, so moving off any other ends a wait. */
-    private leaveStatus;
-    /** 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;
-    setTaskVerdict(id: string, verdict: Task['verdict']): void;
-    /**
-     * How the task's latest attempt ended, and the handoff it left (ADR-0047),
-     * kept as its digest. An attempt that left no handoff clears the one before
-     * it: the plan holds the latest attempt's, as it does the summary.
-     */
-    setTaskOutputSummary(id: string, summary: Task['outputSummary'], handoff?: StoredHandoff): void;
-    /** The owner is saved with the session it belongs to, and dropped with it. */
-    setTaskRunnerSessionId(id: string, runnerSessionId: string | undefined, owner?: RunnerId): void;
-    setCarriedFrom(id: string, runner: RunnerId): 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, runnerSessionCost?: RunnerSessionCost, sessionId?: 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;
-}
-
-/**
- * Who writes a task's assignment. It decides what a model the writer names
- * meets where the task's runner does not offer it or the allowlist excludes it
- * (ADR-0003), which runners it may put a task on, and whether a live runner's
- * hold applies (ADR-0041):
- *
- * - `plan`: a whole plan the planner submitted, and every planner task as it
- *   lands. A stray model is replaced, and the planner is told what moved.
- * - `edit`: the planner's edit. A stray model is refused, which the planner
- *   answers in the same reply.
- * - `user`: a user's direct edit. A stray model is refused, with the reason.
- * - `userAdd`: a task the user adds. A stray model is replaced, and the user
- *   is told what moved.
- * - `runner`: a switch made with the runner's own `/model`, written as the
- *   user's edit. The runner already runs it, so neither the allowlist nor the
- *   live runner's hold applies.
- */
-type AssignmentWriter = 'plan' | 'edit' | 'user' | 'userAdd' | 'runner';
-/**
- * What an assignment is resolved against: the discovered models, the manifest
- * modes and the allowlist, as the session holds them when the write lands —
- * the same catalog the planner's per-turn block shows, so nothing is refused
- * that the planner was never told about.
- */
-interface AssignmentCatalog {
-    /** A runner absent, or listed with nothing, has models discovery could not find, not none. */
-    modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>;
-    /** Absent when no runner's modes are known: no mode is then derived. */
-    runnerModes?: Partial<Record<RunnerId, readonly RunnerModeInfo[]>>;
-    /** Raw (unfiltered) allowlist, keyed by runner; read through {@link effectiveAllowlist}. */
-    perRunnerAllowlist?: Partial<Record<RunnerId, string[]>>;
-    /** Full (true) or Guarded: the mode a derived task lands on unless it is read-only (ADR-0001). Full when absent. */
-    autonomousDefault?: boolean;
-    /**
-     * Whether a task's runner is live: an attempt of it is claimed, running,
-     * quiet or waiting on someone. Its model, effort and runner are then that
-     * runner's (ADR-0041): the process was started on them, and only the
-     * runner's own command moves them. Absent means none is.
-     */
-    liveRunner?: (taskId: string) => boolean;
-}
-/** What a runner offers a task, as discovery and its manifest have it. */
-interface RunnerCatalog {
-    models: DiscoveredModel[];
-    modes: RunnerModeInfo[];
-}
-/** A change the resolver made to what was written, named so it is never silent (ADR-0001). */
-interface AssignmentAdjustment {
-    taskId: string;
-    title: string;
-    field: 'assignedModel' | 'thinkingEffort';
-    from: string | null;
-    to: string | null;
-}
-
-/** Plan placement and dependency rules, shared with browser-bundled surfaces. */
-interface TreeTask<T> {
-    id: string;
-    order: number;
-    title: string;
-    subtasks?: readonly T[];
-}
-interface DependencyTask<T> extends TreeTask<T> {
-    dependencies: readonly string[];
-}
-interface TaskPlacement<T> {
-    task: T;
-    parent?: T;
-    ancestors: readonly T[];
-    siblings: readonly T[];
-    label: string;
-}
-declare function walkPlan<T extends TreeTask<T>>(tasks: readonly T[]): Generator<TaskPlacement<T>>;
-declare function taskPlacement<T extends TreeTask<T>>(tasks: readonly T[], id: string): TaskPlacement<T> | undefined;
-/** Includes the root: deletion has to detach every edge into the removed tree. */
-declare function subtreeIds<T extends TreeTask<T>>(tasks: readonly T[], id: string): Set<string>;
-/** Pickers offer earlier siblings; API validity is independent of display order. */
-declare function dependencyCandidates<T extends TreeTask<T>>(tasks: readonly T[], taskId?: string): T[];
-/** The surviving tasks whose dependency lists a subtree removal will change. */
-declare function dependentsOf<T extends DependencyTask<T>>(tasks: readonly T[], taskId: string): T[];
-interface DependencyCheck {
-    ok: boolean;
-    error?: string;
-}
-declare function canSetDependencies<T extends DependencyTask<T>>(tasks: readonly T[], taskId: string, dependencies: readonly string[]): DependencyCheck;
-
-/**
- * Targeted task edits emitted by the planner conversation (the 'task_ops'
- * ConversationTurn). Task references accept a task id, a "#<order>" ref, or a
- * bare order number — cheap models rarely echo UUIDs correctly.
- */
-/**
- * A task as the planner writes it: its fields, less the mode, plus whether it
- * must not change files (ADR-0031), and `thinkingEffort` as a name for its
- * model's effort, so an effort can change without restating the model.
- */
-type PlannerTaskSpec = Partial<Task> & {
-    readOnly?: boolean;
-    thinkingEffort?: string | null;
-};
-type TaskOp = {
-    op: 'update';
-    taskId: string;
-    changes: PlannerTaskSpec;
-} | {
-    op: 'add';
-    task: PlannerTaskSpec;
-    handle?: string;
-} | {
-    op: 'remove';
-    taskId: string;
-} | {
-    op: 'reorder';
-    taskIds: string[];
-} | {
-    op: 'merge';
-    taskIds: string[];
-    merged: PlannerTaskSpec;
-    handle?: string;
-} | {
-    op: 'split';
-    taskId: string;
-    parts: PlannerTaskSpec[];
-    handle?: string;
-} | {
-    op: 'rearm';
-    taskId: string;
-    changes?: PlannerTaskSpec;
-};
-declare function textHasTaskOps(text: string): boolean;
-/** Parse a `{"taskOps":[...]}` reply. Throws PlanParseError when the JSON is unusable. */
-declare function parseTaskOpsJson(text: string): TaskOp[];
-/** Which op of a batch a refusal is about: its number among the ops the call wrote, from 1. */
-interface OpRef {
-    number: number;
-    kind: string;
-}
-/** One reason a batch was refused, and the op it is about; absent for the batch as a whole, its order say. */
-interface OpRefusal {
-    op?: OpRef;
-    message: string;
-}
-/** A refusal as the planner reads it, its op named first. */
-declare function opRefusalText({ op, message }: OpRefusal): string;
-interface ApplyTaskOpsResult {
-    ok: boolean;
-    tasks: readonly Task[];
-    /** {@link refusals} as the planner reads them. */
-    errors: string[];
-    refusals: OpRefusal[];
-    /** Human-readable summary of what changed, for the chat transcript. */
-    summary: string[];
-    /** On ok, what the batch's tasks were adjusted to beyond what the planner wrote, as they stand at its end. */
-    adjustments?: AssignmentAdjustment[];
-    /** 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
- * (rewiring every dependent of any selected task to the survivor) keep the
- * dependency graph valid? Rejects locked tasks and merges whose rewiring would
- * introduce a cycle. Display order is NOT checked here — neither
- * consecutiveness (a UI concern) nor a dependency the merge pulls out of order,
- * which {@link applyTaskOps} repairs; refusing on order would make this
- * pre-flight stricter than the applier it stands in for.
- */
-declare function canMergeTasks(tasks: readonly Task[], selectedIds: string[]): {
-    ok: boolean;
-    error?: string;
-};
-/**
- * The shape the dependency helpers below read. Structural rather than `Task`,
- * because the TUI projects tasks into its own `TaskView`: a surface's
- * dependency picker and the API's validation must agree on which dependencies
- * are legal, and a signature only core can satisfy would have forced the TUI
- * to keep a second copy of the rule.
- */
-interface TaskRef {
-    id: string;
-    order: number;
-    title: string;
-    dependencies: string[];
-}
-
-/** Pre-flight check for a split: the task exists and is not locked by execution. */
-declare function canSplitTask(tasks: readonly Task[], taskId: string): {
-    ok: boolean;
-    error?: string;
-};
-/**
- * Apply task ops to a snapshot of the plan, atomically: either every op
- * applies and the result validates (deps resolve, no cycles, running and
- * completed tasks untouched), or nothing is returned and `errors` explains
- * why. The caller commits `tasks` on ok.
- *
- * `earlierHandles` are the handles an earlier batch of the same planner turn
- * gave, each with the id of the task it made (ADR-0022 P2): this batch may
- * name those tasks by them, and may not give one of them again.
- */
-declare function applyTaskOps(currentTasks: readonly Task[], ops: TaskOp[], runners: RunnerId[], catalog?: AssignmentCatalog, earlierHandles?: ReadonlyMap<string, string>): ApplyTaskOpsResult;
-
-/**
- * Task skills end to end (ADR-0024): a skill reaches a runner only by being
- * attached to its task in the plan, and Ordewell puts its body in the task's
- * prompt — so it works the same on every runner, and nothing is written to a
- * harness's own skills directory.
- */
-/** Where a task's skill names are looked up: global first, then the workspace folders it reads. */
-interface SkillLookup extends Pick<SkillsService, 'findSkill' | 'searchedDirs'> {
-    /**
-     * Set when tasks get worktrees: of `skills`, the workspace ones git will not
-     * carry into them, each SKILL.md path mapped to the folder to commit,
-     * relative to the workspace root.
+     * on the user, whatever for, stays waiting. `keepFailed` is what failed in
+     * the reply autorun's run follows: nobody asked for those to run again.
      */
-    uncommitted?(skills: readonly SkillInfo[]): Promise<Map<string, string>>;
-}
-/**
- * Where a workspace's skills are read, known without asking git: the repos
- * of its group in layout order (`['.']` for one repository), and whether
- * tasks will get worktrees, which only a committed skill reaches.
- */
-interface SkillLayout {
-    repos: readonly string[];
-    worktrees: boolean;
-}
-
-/**
- * Where the run's tasks will work: `false` in the shared workspace root;
- * otherwise each in its own worktree of every repo of the group (ADR-0013,
- * ADR-0014), which is what decides if tasks on the same file must be ordered.
- */
-type IsolatedExecution = false | RepoGroupLayout;
-interface PlannerModes {
-    autonomousDefault: boolean;
-    /** Not a toggle: a fact about the run. */
-    isolatedExecution: IsolatedExecution;
+    resetForRun(opts?: {
+        preserveCompleted?: boolean;
+        edited?: boolean;
+        keepFailed?: ReadonlySet<string>;
+    }): void;
     /**
-     * Where the run's tasks will look their skills up (ADR-0024), also a fact
-     * about the run. A plan attaching a planner skill is refused against it,
-     * and a coding agent's submit_plan call is refused in its turn rather than
-     * accepted and then failed. Absent: the plan is not checked.
+     * Execute's fresh chance with work already live (ADR-0053), which
+     * `resetForRun` would take back: only what failed and is not at work is
+     * readied, and a check between rounds still leaves its body to run first.
      */
-    taskSkills?: SkillLookup;
-}
-
-type IsolationNoticeLevel = 'info' | 'warn' | 'error';
-/**
- * How an attempt that may run in a worktree gets one: fresh, the kept one for
- * a repair, restoring the previous attempt's work, or fresh and thrown away
- * whatever it changes, for a read-only task (ADR-0046).
- */
-type AttemptIntent = 'fresh' | 'repair' | 'readOnly' | PrepareIntent;
-/**
- * What adopting a persisted run found: nothing to change, landed work git
- * shows the user has merged since, or a settled run that had nothing left to
- * hand over and was cleared up.
- */
-type AdoptOutcome = 'unchanged' | 'changed' | 'cleared';
-interface AttemptWorkspace {
-    cwd: string;
-    worktree: boolean;
-    /** The task workspace holding the attempt's worktrees, which `cwd` is in; set with `worktree` when it was prepared. */
-    workspace?: string;
-    /** Set for a `restore` in a worktree; absent in the checkout, where the previous attempt's edits remain. */
-    previousWork?: PreviousWork;
-}
-/**
- * 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;
-    /** The run was cleared up and forgotten: nothing was handed over, or it was discarded. */
-    closed(): void;
-    /** The run is over, discarded or cleared up, whether or not its record stays: nothing it carried goes on (ADR-0045 L5). A Merge all it goes on after is not this. */
-    ended(): void;
-    /** Already said through the notifications; also for a surface that shows no toasts. */
-    notice(level: IsolationNoticeLevel, message: string): void;
-    /** A clean-up took the branches these resolver tasks would merge, and their links with them. */
-    resolversEnded(resolverIds: readonly string[]): void;
-}
-interface IsolationRunControllerDeps {
-    isolation: IWorktreeIsolation;
-    config: IConfig;
-    notifications: INotification;
-    workspaceRoot: () => string;
-    listener: IsolationRunListener;
+    readyFailed(live: (taskId: string) => boolean): void;
+    /** See {@link releaseMadeManual}; `live` names what a runner still holds. */
+    releaseMadeManual(live?: (taskId: string) => boolean): void;
+    private ready;
+    /** A delegated task's checks; its scheduler, which knows what makes a task read-only, says which those are. */
+    checksOf: (task: Readonly<Task>) => readonly Task[];
+    markCompleted(id: string): void;
+    markFailed(id: string): void;
+    markSkipped(id: string, reason?: string): void;
+    markInProgress(id: string): void;
+    /** Its first attempt is starting: from now on its chat exists, whatever becomes of the attempt. */
+    markAttempted(id: string): void;
+    /** Its attempt starts: the number now tells its waits from the last attempt's, so they count from nothing (ADR-0053). */
+    markAttemptStarted(id: string): void;
+    /** Saved beside the wait it explains: see {@link Task.parkedQuestion}. */
+    parkQuestion(id: string, question: 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;
     /**
-     * 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.
+     * A new attempt of the task, from nothing it earned. A loop's check starts
+     * its rounds over (ADR-0045 L7), unless `sameRound`: a resume after a usage
+     * limit goes on with the attempt the limit cut short.
      */
-    liveTasks: () => ReadonlySet<string>;
-    /** What a task depends on now, directly or not, read as it lands: the plan may let go of that later, and a revert may not (ADR-0054). */
-    landedOn: (taskId: string) => readonly 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 readonly landedOn;
-    private run;
-    /** See {@link mergedRun}. */
-    private merged;
-    /** An adoption stays scoped even while cleanup temporarily leaves no run record. */
-    private adoptions;
-    /** 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;
-    private opened;
-    /** 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;
-    /** How many starts it has turned away; a replay can be turned away again in the same run. */
-    private turnedAway;
-    /** 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;
-    /**
-     * The id of the plan's last isolated run once it closed with everything it
-     * landed merged into the user's branch and was cleared up: what tells a
-     * Merge all asked for after it, which has nothing to merge, from one in a
-     * plan that never isolated (ADR-0029). Null while the plan holds a run
-     * record, and once a later run decides how it executes. Saved with the plan.
-     */
-    get mergedRun(): string | null;
-    get isOpen(): boolean;
-    /** How many runs have opened: what tells one run's launches from the next one's. */
-    get epoch(): number;
-    /** 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;
-    /** How many starts a dirty tree has turned away: what tells one wait on it from the next (ADR-0053). */
-    get blockedStarts(): number;
-    /** 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. Then git is
-     * asked which landed work the user has merged since the record was saved:
-     * a settled run whose landed work is all in HEAD has nothing left to hand
-     * over, so it is cleared up as Merge all would have, unless it still holds
-     * work that never landed (ADR-0013).
-     *
-     * Deliberately not reported to the listener: adopting is not a change of the
-     * session's own, and a host that adopts without persisting (VS Code's
-     * restore) would otherwise write a new session file on every reload. What
-     * git changed is returned instead, for the caller to save where it can and
-     * announce. A plan loaded meanwhile supersedes this adoption, which then
-     * touches nothing and resolves `unchanged`. `mergedRun` is the plan's saved
-     * {@link mergedRun}.
-     */
-    adopt(state: PlanIsolation | null, mergedRun?: string): Promise<AdoptOutcome>;
-    /** 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(resume: () => Promise<void>): Promise<boolean>;
-    /**
-     * Whether the run in force, or else the next one, gives each task its own
-     * worktrees, and of which repo group — what the planner is told, since it
-     * decides whether tasks on the same file have to be ordered and which shared
-     * paths two tasks must not edit at once. A tree that would block counts as
-     * not isolating: the user may yet run without isolation, and ordering is
-     * the safe rule then.
-     */
-    plannerLayout(): Promise<IsolatedExecution>;
-    /**
-     * Where the workspace's skills are read, and whether tasks get worktrees.
-     * Read synchronously inside a planner turn or a chip edit, so it comes from
-     * the files, not git or the planner's last layout: a restored session is
-     * right from its first edit. The run's repos while it isolates; otherwise
-     * the group the workspace holds, in worktrees unless isolation is off or
-     * this run chose to share the root.
-     */
-    skillLayout(): SkillLayout;
-    /**
-     * Go on with 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; `reread` does nothing to the
-     * tree, so the replay asks about it again (ADR-0053). Returns the parked start
-     * for the caller to replay; null when nothing was parked.
-     */
-    continueBlocked(how: 'stash' | 'shared' | 'reread'): Promise<(() => Promise<void>) | null>;
-    /**
-     * The working directory of an attempt that may run in a worktree — which
-     * attempts do is the attempt kind's to say (see `attemptKind.attemptCwd`):
-     * the worktree prepared for it in an isolated run, the kept one for a
-     * conflict repair, else the workspace root. `worktree` says which. Does not
-     * itself report a worktree it creates as a change — the caller does once
-     * 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: AttemptIntent): Promise<AttemptWorkspace>;
-    /** The workspace root, for an attempt that runs outside any worktree. */
-    workspaceCwd(task: Task): Promise<{
-        cwd: string;
-        worktree: boolean;
-    }>;
-    private reopenCwd;
-    private prepareCwd;
-    /**
-     * Land a task's work on the run's integration branches. The record is
-     * reported changed once the landing is set and before the first merge, so
-     * a crash mid-landing leaves the tips to roll back to, and again once it
-     * settles. A git error is `failed`, never a throw.
-     */
-    integrate(task: Task, commit?: HandoffCommit): Promise<IsolationOutcome>;
-    private keepLandedOn;
-    /** What a conflict repair's work shows (ADR-0015); git that cannot tell counts against it. */
-    verifyRepair(task: Task): Promise<RepairEvidence>;
-    /**
-     * Let go of a task's worktree. `keep` leaves it and its branch for
-     * inspection; otherwise both go. A landing still in flight settles first, so
-     * the worktree is never torn down underneath its merge. Bound to the run
-     * the call was made in: a plan loaded meanwhile adopts its own run, whose
-     * records share these task ids and are not this release's to touch.
-     */
-    release(taskId: string, opts: {
-        keep: boolean;
-    }, landing?: Promise<unknown> | null): Promise<void>;
-    /**
-     * Close the open run. An isolated one hands its integration branch over for
-     * review — unless everything it landed is merged already, at merge gates or
-     * by the run's automatic Merge all, which leaves nothing to hand over, so it
-     * is cleared up as a Merge all would have.
-     */
-    close(): Promise<void>;
-    /**
-     * Whether a task's landed work still waits to be merged into the user's
-     * branch — what holds an ops or user task at its merge gate (ADR-0020). A
-     * task with no record never landed anything to wait for.
-     */
-    awaitsMerge(taskId: string): boolean;
-    /**
-     * Look again for landed work the user has merged — by Merge all, or by hand
-     * with git — or has taken back out. Resolves true when a mark changed.
-     */
-    refreshInHead(): Promise<boolean>;
-    /** Whether any landed work reads as merged: an answer git can take back, if the user takes the merge out. */
-    get readsMerged(): boolean;
-    /** Mark the run's landed work as git finds it now; true when a mark changed. */
-    private findLanded;
-    /** The run landed something and every landing is in the user's HEAD. */
-    private allMerged;
-    /**
-     * The tracked state of the workspace as an attempt whose tree is checked
-     * starts (see `attemptKind.checksTree`), for {@link filesChangedSince}
-     * (ADR-0020). Null where the check does not run: a run that shares the
-     * workspace root, where every task's edits land in it, or a workspace git
-     * cannot isolate at all.
-     */
-    snapshotWorkspace(): Promise<TreeSnapshot | null>;
-    /** Tracked files changed since `snapshot`; none when the run has since gone on in the workspace root. */
-    filesChangedSince(snapshot: TreeSnapshot | null): Promise<string[]>;
-    /**
-     * A stop or a plan load: the open run ends without a handoff and a parked
-     * start is dropped. `keepOpen` spares a run the scheduler is still driving.
-     */
-    interrupt(opts?: {
-        keepOpen?: boolean;
+    retry(id: string, opts?: {
+        sameRound?: boolean;
     }): void;
     /**
-     * Mark which added task resolves which conflict. The resolver merges the
-     * conflicted task's branch by hand in its own worktree; once that lands, the
-     * conflicted task can land in turn — through the same merge, so a resolver
-     * that did not really bring it along conflicts again instead of being taken
-     * at its word.
-     */
-    linkResolver(resolverId: string, conflictedId: string): void;
-    /** The conflicted task a landed resolver was added for, forgotten as it is returned. */
-    takeResolver(resolverId: string): string | undefined;
-    /** The tasks added to resolve this task's conflict: one, but for a plan saved before that was the rule (ADR-0015). */
-    resolversOf(conflictedId: string): string[];
-    taskDiff(taskId: string, options: TaskDiffRead): Promise<TaskDiffResult>;
-    reviewDiff(): Promise<string>;
-    /**
-     * "Merge all": the run's integration branches into whatever the user has
-     * checked out, in every repo or none. During a run it merges what has
-     * landed so far and the run goes on (ADR-0020): its branches stay for the
-     * tasks still to land. Once a settled run merged everything, it has nothing
-     * left to hand over, so it is cleared up and forgotten; a branch the user's
-     * HEAD somehow does not contain stays for the next run's sweep.
-     */
-    merge(): Promise<IsolationMergeResult>;
-    /** What git says of landed work a revert would take; see {@link IWorktreeIsolation.readLanded}. */
-    readLanded(taskIds: readonly string[]): Promise<LandedWork>;
-    /**
-     * Revert tasks' landings on the integration branches (ADR-0054). The record
-     * is reported changed once the tips are set and before the first commit,
-     * again as each commit is made, so a crash leaves it to tell them from
-     * anyone's, and once it settles. Bound to the run it was
-     * asked in: a plan loaded meanwhile has records of its own under these ids,
-     * and is saved without what this would write to that run's branches, so it
-     * stops the revert and leaves them as they were.
-     */
-    revert(taskIds: readonly string[], watch: Omit<RevertWatch, 'persist'>): Promise<IsolationRevertResult>;
-    /**
-     * Worktrees and task branches go; the integration branch and the record stay
-     * for review and merge. Refused while a task of the run is still live.
-     */
-    cleanup(): Promise<void>;
-    /**
-     * The run and everything it made go, and the plan forgets it; the next run
-     * starts afresh. Refused while a task of the run is still live.
-     */
-    discard(): Promise<void>;
-    /** The records of tasks still live, whose worktrees no clean-up of the whole run may take. */
-    private liveRecords;
-    private refuseWhileLive;
-    /**
-     * Clear a settled run up once everything it landed is merged — and only
-     * when nothing else is left in it: a live task, or a worktree holding work
-     * that never landed, keeps the whole run, worktrees and branches, rather
-     * than leaving that work to a deletion.
-     */
-    private clearMerged;
-    /** The records that keep a settled run from being cleared up: live, or holding work that never landed. */
-    private holdouts;
-    /** The run's worktrees and merged branches go; false, said, when git would not let them. */
-    private discardMerged;
-    /** Say what a removal kept back instead of deleting: where the work went, or which worktree stayed. */
-    private report;
-    /** The branches the links' resolvers would merge have gone: the links go, and the scheduler is told of the tasks left. */
-    private endResolvers;
-    /** The run goes from the plan; `merged` names it as {@link mergedRun} when everything it landed was merged. */
-    private forget;
-    private assess;
-    private activate;
-    private begin;
-    /** What earlier runs left merged in the group goes; a failure here is worth a word, never a stopped run. */
-    private sweep;
-    /**
-     * The plan's run carries on while it still has any record: anything landed
-     * means a resumed plan's dependents must start from a tip that holds their
-     * predecessors' work, and anything held — a kept attempt, a conflict, a
-     * repair — is work the user may still want, which a fresh run's mint would
-     * delete. Only a run with no records at all is superseded, and not one that
-     * reverted the tasks it had: a retry starts from its tip (ADR-0054).
-     */
-    private continuableRun;
-    /**
-     * A run with no records at all holds only superseded attempts, so it goes —
-     * but its integration branch only where the user's HEAD contains it, as does
-     * that of a run that cannot be continued for another reason (it ran from a
-     * different workspace path): only the user gives landed work up.
-     *
-     * False when `interrupted` came while git was minting: a newer activation
-     * may be minting its own run, so this one is never installed over it, and
-     * is discarded rather than left as branches no record names.
+     * A pass judged one result, and a new attempt of a delegated task makes
+     * another (ADR-0055 D8): its checks run again, whatever their status, their
+     * rounds starting over. A check not started yet has nothing to take back. The
+     * retries of every kind pass here; the claim asks for the starts that do not.
      */
-    private mint;
-    private reportCopies;
-    private reportSetupFailures;
-    private tell;
+    takeBackChecks(id: string): void;
+    /** Its landed work was reverted (ADR-0054): as a retry leaves it, marked so until it starts. */
+    markReverted(id: string): void;
+    /** A loop's check counts its rounds afresh from its next run (ADR-0045 L7). */
+    startRoundsOver(id: string): void;
+    /**
+     * The loop runs its check again, as its next round (ADR-0045 L5): a new
+     * attempt, the round counted on, and nothing of the round before kept on
+     * the task — its report went to the body, and stays in its attempt's log.
+     */
+    repeat(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;
+    /** One of the task's waits is over, so what it waits on next is another (ADR-0053). */
+    endWait(id: string): void;
+    /** Work under way is the one status nobody could be waiting on, so moving off any other ends a wait. */
+    private leaveStatus;
+    /** 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;
+    setTaskVerdict(id: string, verdict: Task['verdict']): void;
+    /**
+     * How the task's latest attempt ended, and the handoff it left (ADR-0047),
+     * kept as its digest. An attempt that left no handoff clears the one before
+     * it: the plan holds the latest attempt's, as it does the summary.
+     */
+    setTaskOutputSummary(id: string, summary: Task['outputSummary'], handoff?: StoredHandoff): void;
+    /** The owner is saved with the session it belongs to, and dropped with it. */
+    setTaskRunnerSessionId(id: string, runnerSessionId: string | undefined, owner?: RunnerId): void;
+    setCarriedFrom(id: string, runner: RunnerId): 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, runnerSessionCost?: RunnerSessionCost, sessionId?: 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;
 }
 
 /** A continue the user asked for: their message, and the runner session it resumes (ADR-0018, K1). */
@@ -1001,6 +621,9 @@ interface Continuation {
  * - `carryOver`: a change task paused on `from`'s usage limit and moved to
  *   another runner (ADR-0018, U1). A fresh session — none can cross runners —
  *   in a worktree that starts from the paused attempt's work.
+ * - `delegated`: a delegated task's attempt, a child plan in its worktree
+ *   (ADR-0055 D3). `readOnly` lands nothing, and its worktree goes as a
+ *   read-only task's does.
  */
 type AttemptKind = {
     readonly kind: 'change';
@@ -1017,13 +640,17 @@ type AttemptKind = {
 } & Readonly<Continuation>) | {
     readonly kind: 'carryOver';
     readonly from: RunnerId;
+} | {
+    readonly kind: 'delegated';
+    readonly readOnly: boolean;
 };
 /**
  * What a task's work is, whichever attempt does it: a change that lands, an
  * ops task's effects from the checkout (ADR-0020), or a read-only task's,
- * which lands nothing (ADR-0046).
+ * which lands nothing (ADR-0046), or a child plan's (ADR-0055), which lands
+ * unless it is read-only.
  */
-type TaskWork = 'change' | 'ops' | 'readOnly';
+type TaskWork = 'change' | 'ops' | 'readOnly' | 'delegated' | 'delegatedReadOnly';
 
 /** Which repair of a task an attempt is, of the most `conflictRepairAttempts` allows. */
 interface RepairAttempt {
@@ -1075,6 +702,8 @@ interface LandingDeps {
     tasks: Pick<PlanStore, 'get' | 'planTasks'>;
     /** Whether a repair merge's message ends with the Planned-with trailer; read as the prompt is built. */
     plannedWith?: () => boolean;
+    /** What this node's ancestors protect, which accumulates down a tree (ADR-0056 M4). */
+    inheritedProtectedPaths?: () => readonly string[];
 }
 /**
  * Landing and Conflict repair (ADR-0013, ADR-0014, ADR-0015): a passed
@@ -1091,6 +720,7 @@ declare class Landing {
     private readonly config;
     private readonly tasks;
     private readonly plannedWith;
+    private readonly inheritedProtectedPaths;
     constructor(deps: LandingDeps);
     /**
      * Land a passed attempt's work. One whose worktree has no unlanded record
@@ -1115,6 +745,9 @@ declare class Landing {
      * must not bring it in anyway.
      */
     settleRepair(task: Task, verdict: Verdict, current: () => boolean): Promise<LandingOutcome>;
+    /** A repair lands after the verdict that held the work to its protected paths, so it is held to them here (ADR-0055 D7, D14). */
+    private protectedPathsTouched;
+    private protectedPaths;
     /** A repair that ended without landing leaves the task as its conflict did: waiting on the user, worktree and refs kept. */
     unrepaired(task: Task, why: string): Promise<Extract<LandingOutcome, {
         kind: 'awaiting_user';
@@ -1506,7 +1139,56 @@ declare function scriptExitText(exit: Omit<Extract<TaskLogEvent, {
  */
 declare function digestTaskLog(events: readonly TaskLogEvent[], maxCalls: number): string;
 
-/** The session's saved task logs, as `read_task` reads them (ADR-0018, P1). */
+/** One node as a tree's log names it (ADR-0058 S3). */
+interface SubtreeNode {
+    path: NodePath;
+    sessionId: string;
+    /** The delegated task of the plan above it. */
+    taskId?: string;
+}
+/** A plan of the tree, read afresh: its tasks, and the logs of its attempts. */
+interface NodePlan {
+    node: NodePath;
+    tasks: readonly Task[];
+    logs: TaskLogReader;
+}
+interface SubtreeSource {
+    /** The node reading: what is below it is what this reads. */
+    here: NodePath;
+    /** Every node ever opened below `here`, closed ones too: a reference outlives the child it names (ADR-0057 R1). */
+    nodes(): readonly SubtreeNode[];
+    /** What a node's session file holds of its plan, which is read only when asked for (ADR-0055 D17). */
+    plan(node: SubtreeNode): readonly Task[] | undefined;
+    logs(node: SubtreeNode): TaskLogReader;
+}
+/**
+ * The plans below one node, as a reference reads them (ADR-0057 R1): a
+ * reader's reach goes down and never up, or sideways, so a child's tools see
+ * nothing of the plan that holds its check (ADR-0055 D8).
+ */
+declare class Subtree {
+    private readonly source;
+    private readonly reach?;
+    constructor(source: SubtreeSource, reach?: ReadonlySet<string> | undefined);
+    /** What a task reads: only what hangs from a delegated task its readable set holds. */
+    reachedBy(readable: ReadonlySet<string>): Subtree;
+    private nodes;
+    private planOf;
+    /** Every plan below that has been saved, nearest first, each once: a Continue opens a new node for the same child and its one plan (ADR-0055 D17). */
+    plans(): NodePlan[];
+    /** The plan a pinned reference names, whichever of a child's nodes it was pinned against. */
+    planAt(path: NodePath): NodePlan | undefined;
+    /**
+     * The plan a written path names. A report shows a path from the root and an
+     * author writes one from its own plan, so a path that starts at this node
+     * and goes on is read as shown; anything else is read from here.
+     */
+    at(path: string): NodePlan | undefined;
+    /** The same as a reference is pinned against it. */
+    readonly below: (path: string) => BelowPlan | undefined;
+}
+
+/** The session's saved task logs, as `read` reads them (ADR-0018, P1). */
 interface TaskLogReader {
     /** The attempts of a task that have a saved log, oldest first. */
     attempts(taskId: string): number[];
@@ -1515,6 +1197,262 @@ interface TaskLogReader {
     patch?(taskId: string, attempt: number): Buffer | undefined;
 }
 
+/** Where the board's `file` evidence is compared (ADR-0057 R9). */
+interface BoardGit {
+    /** The branch this node's plan lands on; undefined with no run yet. */
+    branch(): string | undefined;
+    /** The blob `file` holds on `branch`: null where it holds none, undefined where the branch cannot be read. */
+    blob(branch: string, file: string): Promise<string | null | undefined>;
+}
+/** The log's side of a board. */
+interface BoardLog {
+    post(node: NodePath, draft: BoardDraft): BoardEntry | null;
+    board(node: NodePath): readonly BoardEntry[];
+}
+interface NodeBoardDeps {
+    log: BoardLog;
+    node: NodePath;
+    git: BoardGit;
+    /** What this plan's checks read and run: what no pin may hold (R10). */
+    checks?(): readonly CheckWord[];
+}
+/** The blob of a file where its author works, as git would name it; undefined for what cannot be read, which goes unpinned. */
+type WorkBlobs = (file: string) => Promise<string | undefined>;
+/**
+ * One node's view of the tree's boards (ADR-0057 R8 to R10): it posts to its
+ * own, and reads that and its ancestors' by pull. Nothing here wakes or tells
+ * anyone, so it is no channel between siblings (R7). What is stale or contested
+ * is worked out here, as a reader asks, from what the log and git hold.
+ */
+declare class NodeBoard {
+    private readonly deps;
+    constructor(deps: NodeBoardDeps);
+    get node(): NodePath;
+    /** Nearest first: this node, then each ancestor. */
+    private chain;
+    private readable;
+    /** The file evidence an entry pins, read now: what its author saw and what the branch held. */
+    private pinned;
+    /** Why this may not be posted, or null. */
+    private refusal;
+    /** `work` reads where the author works: its files are pinned from there (R9). */
+    post(entry: BoardPost, by: Omit<BoardAuthor, 'node'>, work?: WorkBlobs): Promise<McpToolReply>;
+    /** Whether a pinned file has moved past what its entry was written on. */
+    private stale;
+    private marked;
+    /** `read` of `board`, or of one entry by its reference. */
+    read(written: string): Promise<McpToolReply>;
+    /** The pins a new descendant of this node is told (R10). */
+    pins(): string[];
+    /**
+     * A delegated task's `contract`s for what it provides, onto this board as it
+     * lands (R6), which is how a sibling reads them: a node reads its ancestors'
+     * boards and never another's. Each keeps its author, and is read again against
+     * the branch it has landed on. Only what the plan declared rises, and only once.
+     */
+    raise(from: readonly BoardEntry[], provides: readonly string[]): Promise<void>;
+}
+
+/** One node as the log leaves it. */
+interface TreeNode {
+    path: NodePath;
+    sessionId: string;
+    taskId?: string;
+    limit: number;
+    /** What its open children hold. */
+    committed: number;
+    /** Its own, and what its closed children spent. */
+    spent: number;
+    /** The subplanner's share of `reserve`, held for its next turn. */
+    kept: number;
+    /** What raises gave it: a grant to its task, which outlives this node, so what a parent's turn takes back comes off `limit` and not off this (M5). */
+    raised: number;
+    open: boolean;
+    /** Children it has ever opened: the next one's id. */
+    opened: number;
+    /** What was posted on its board, oldest first; absent on a node nothing was (ADR-0057 R8). */
+    board?: BoardEntry[];
+}
+/** A node's four numbers (ADR-0056 M5). `spent + committed + reserve ≤ limit`, unless `spent` overshot, as nothing can recall a request. */
+interface BudgetNumbers {
+    limit: number;
+    committed: number;
+    spent: number;
+    reserve: number;
+}
+/** What a claim holds until its attempt ends. */
+interface BudgetHold {
+    /** Idempotent. */
+    release(): void;
+}
+type Carved = {
+    ok: true;
+    mandate: Mandate;
+    budget: NodeBudget;
+} | {
+    ok: false;
+    refusal: MandateRefusal;
+};
+/** One node's side of the ledger, as a Session spends it. */
+interface NodeBudget {
+    readonly path: NodePath;
+    readonly sessionId: string;
+    readonly tree: TreeLedger;
+    /** Why a new session may not start here, or null. Changes nothing: a claim's refusal is also asked with no claim to follow. */
+    refusal(): string | null;
+    /** In the claim's synchronous step, so concurrent claims each see the last one's. */
+    hold(): BudgetHold;
+    spent(record: UsageRecord, on: {
+        taskId: string;
+        attempt: number;
+    }): void;
+    /** Why a subplanner's turn may not start, or null: that share, room and its children's room must come to one session. */
+    turnRefusal(): string | null;
+    turnSpent(record: UsageRecord): void;
+    /** `child` asked this turn: it pays first for what the turn cannot (M5). */
+    woken(child: NodePath): void;
+    /** The turn ended: keep one session again, from room, then from the children's. */
+    parked(): void;
+    /** Nothing here can go on, for this reason. Said once, until a raise. */
+    stop(why: string): void;
+    /** Why it stopped, or null: what a parent reads to end it `blocked`. */
+    stoppedFor(): string | null;
+    /** Tell `listener` why, each time this node stops. Returns how to stop being told. */
+    onStop(listener: (why: string) => void): () => void;
+    /** Tell `listener` each time a raise takes: it only moves numbers, so what the node's Session starts again is its own. */
+    onRaised(listener: () => void): void;
+}
+interface TreeLedgerOptions {
+    /** {@link SESSION_RESERVE_TOKENS} unless a test works with smaller numbers. */
+    sessionReserve?: number;
+    /** The log refused a write. What it refused waits and goes with the next. */
+    failed?: (err: unknown) => void;
+}
+/**
+ * The budget ledger (ADR-0056 M5), the root's and shared down its tree. Every
+ * read and decision is synchronous, as a claim is (ADR-0029); what is decided
+ * goes to the log behind it, whole, in the order it was decided. Only budgets
+ * are here: a child's mandate and what to spend it on are its Session's.
+ *
+ * What is live is held here and never logged: nothing is live after a restart.
+ */
+declare class TreeLedger {
+    private readonly store;
+    private readonly tree;
+    private readonly reserve;
+    private readonly failed;
+    /** Sessions holding an allowance, by node. */
+    private readonly live;
+    /** Who pays first for the turn under way, by node. */
+    private readonly wakers;
+    private readonly listeners;
+    private readonly raiseListeners;
+    /** Why each stopped node did, which a raise clears (M5). */
+    private readonly stopped;
+    private pending;
+    private writing;
+    private failureSaid;
+    private constructor();
+    /** Rebuild from the log, and from nothing else (ADR-0058 S3). A log with no root gets one: this is the first carve of a tree. */
+    static open(store: EventStore, root: {
+        sessionId: string;
+        limit: number;
+    }, options?: TreeLedgerOptions): Promise<TreeLedger>;
+    private write;
+    /** What one step decides lands as one batch: the first await lets the step finish. */
+    private flush;
+    /** Everything decided so far has been offered to the log. */
+    flushed(): Promise<void>;
+    /** The Session holding the tree is closing. */
+    shutdown(): Promise<void>;
+    private at;
+    private liveReserve;
+    /** What `limit` leaves once its node's spending and children are paid: its reserve and room. */
+    private free;
+    private room;
+    /**
+     * What a claim can take. A turn spends its subplanner's share down until it
+     * parks, and a claim comes at that turn's end: read as it stands, the share
+     * would pay for the claim, and the turn that follows the work would find
+     * nothing and could not report it.
+     */
+    private claimRoom;
+    numbers(path: NodePath): BudgetNumbers;
+    /** What a node can still carve or claim: `limit` less the other three. What `narrow` is handed as the parent's tokens (M4). */
+    left(path: NodePath): number;
+    node(path: NodePath): NodeBudget;
+    /** Every node ever opened under `path`, closed ones too, nearest first: a reference outlives the child it names (ADR-0057 R1). */
+    below(path: NodePath): TreeNode[];
+    /**
+     * A node's board, every opening of one child's together: a Continue opens a
+     * new node for the same child and its one plan (ADR-0055 D17).
+     */
+    board(path: NodePath): readonly BoardEntry[];
+    /** One child's board, closed or not: a fresh retry is a new child with a board of its own (ADR-0055 D15). */
+    boardOf(sessionId: string): readonly BoardEntry[];
+    /** Put an entry on `path`'s board, or null where that board is full. */
+    post(path: NodePath, draft: BoardDraft): BoardEntry | null;
+    /** What `path` and everything under it spent: a closed child is in its parent's `spent`, an open one still its own (M5). */
+    subtreeSpent(path: NodePath): number;
+    /** What a node's task has cost so far: this opening's subtree and every opening before it, since a report of the last alone reads as the whole (ADR-0056 M10). */
+    taskSpent(path: NodePath): number;
+    /** The open node `sessionId` is, if any: what a reopen finds. */
+    nodeOf(sessionId: string): NodeBudget | undefined;
+    /** What every child `parent` opened for `taskId` has spent, closed ones included: a retry's budget is what they left (ADR-0056 M10). */
+    spentOn(parent: NodePath, taskId: string): number;
+    /** What raises gave every child `parent` opened for `taskId`: the tree granted it to the task, on top of its stated budget (ADR-0056 M5, M10). */
+    raisedOn(parent: NodePath, taskId: string): number;
+    private childrenFor;
+    /** Close the children of `parent` that `gone` picks by their task: no session is live in them, so what they hold would stay committed for good. */
+    closeChildren(parent: NodePath, gone: (taskId: string | undefined) => boolean): void;
+    private hold;
+    private openChildren;
+    /** What a turn can reach: what its node has beside its live sessions, and its children's room. */
+    private turnCover;
+    /**
+     * A child's mandate, carved from what `parent` has left (ADR-0056 M4, M5). One
+     * synchronous step, so no second carve can read the same room.
+     */
+    carve(parent: NodePath, mandate: Mandate, request: MandateRequest, child: {
+        sessionId: string;
+        taskId: string;
+    }): Carved;
+    /**
+     * A raise, for the parent's answer to a checkpoint to apply (M5): from what
+     * the parent has left, the child's limit and the parent's `committed` rising
+     * together. Null when it took; otherwise why not.
+     */
+    raise(path: NodePath, tokens: number): string | null;
+    /** Where the user keeps the tree's budget (ADR-0056 M5), read as a carve or a raise is asked for. */
+    setRootLimit(limit: number): void;
+    /**
+     * A child ended, on confirmed close: what it did not spend returns to its
+     * parent and goes no further (M5), so a sibling gets it only by the parent's
+     * next carve. What is still open under it closes first, in the same step.
+     */
+    close(path: NodePath): void;
+    private closeUnder;
+    private nearestOpen;
+    private spend;
+    /**
+     * A call's usage arrives with the next already sent, and nothing recalls a
+     * request, so a node that stopped at its limit would always pass it, by a call
+     * or more. It stops while what it can reach still pays for what is on its way:
+     * the next call of each live session and the one after, each the size of the
+     * one just reported, which a long context only grows from. An estimate, never
+     * more than the reserve that is held for it. No live session means a runner
+     * winding down, with no call to follow.
+     */
+    private stopShortOfLimit;
+    /** Past what it can pay, a node's spending takes its children's room; with none left it is out. */
+    private settle;
+    /** Take up to `short` of the children's room, the child that woke the turn first and then the oldest. Returns what it took. */
+    private takeFromChildren;
+    private park;
+    private spentOut;
+    private stopNode;
+}
+
 /** Where a start stands against the user's Stop (ADR-0029): no longer current once one comes. */
 type Admitted = Pick<StartAdmission, 'current'>;
 type AttemptPhase = 'starting' | 'running' | 'integrating';
@@ -1608,6 +1546,11 @@ type StartWait =
  | {
     kind: 'start-hold';
 }
+/** A delegated task's check is running: its fresh attempt takes that check back, so it waits for it to end (ADR-0055 D8). */
+ | {
+    kind: 'check-running';
+    check: string;
+}
 /** Its merge gate (ADR-0020): the ancestors whose landed work is not in the user's branch yet. */
  | {
     kind: 'merge-gate';
@@ -1864,6 +1807,8 @@ interface EscalationRun {
     mergesAtClose: boolean;
     /** What Merge all would merge now. */
     merge: RunMergeView | null;
+    /** The checks that have not passed work Merge all would merge (ADR-0055 D9): the user's is not held, and its confirmation names them. */
+    mergeHold: readonly string[];
     /** The isolated run's id. */
     id: string | null;
     /** Which of the session's starts a dirty checkout turned away, when one waits on it; null when none does. */
@@ -1890,7 +1835,7 @@ interface EscalationInput {
     holdReason: (taskId: string) => string | null | undefined;
     /** Something will run this check between rounds without being asked (ADR-0045 L5). */
     loopRunsOn: (taskId: string) => boolean;
-    /** A loop carried on with no scheduler starts this task, so the run is open for it alone (ADR-0045 L5). */
+    /** A loop or a delegated task's check carried on with no scheduler starts this task, so the run is open for it alone (ADR-0045 L5, ADR-0055 D8). */
     carried: (taskId: string) => boolean;
     run: EscalationRun;
 }
@@ -1979,6 +1924,8 @@ type SerializedTaskStatus = {
     loop?: TaskLoop;
     /** The round a loop's check is in, past its first (ADR-0045 L5); absent on round 1 and on any other task. */
     loopRound?: number;
+    /** A delegated task's row: its child's tasks, what is left of its budget, a Stop still winding down (ADR-0055 D20); absent on any other task and when it has nothing to say. */
+    delegation?: DelegatedRow;
 };
 /**
  * Landed work not yet in the user's branch. `paused` means the running plan
@@ -2033,6 +1980,8 @@ type SerializedTask = {
     loop?: TaskLoop;
     /** As on {@link SerializedTaskStatus}: only on a loop's check past its first round. */
     loopRound?: number;
+    /** What a delegated task's child plan must achieve (ADR-0055 D1); absent on any other task. */
+    goal?: string;
 };
 /** Skill loads go out as notices: their bodies are for the planner, and stay in the session. */
 type SerializedConversationMessage = Omit<ConversationMessage, 'skill'> & {
@@ -2390,7 +2339,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' | 'completionReceived' | 'attaching' | 'isolation' | 'checkpoint' | 'queued' | 'continuable' | 'awaitingApproval' | 'mergeGate' | 'forcedPastGate' | 'waitsForApproval' | 'holdReason' | 'loopStranded' | 'handoff' | 'attempted'>>;
+type RunTaskStatus = Partial<Pick<SerializedTaskStatus, 'verdict' | 'idleSince' | 'completionReceived' | 'attaching' | 'isolation' | 'checkpoint' | 'queued' | 'continuable' | 'awaitingApproval' | 'mergeGate' | 'forcedPastGate' | 'waitsForApproval' | 'holdReason' | 'loopStranded' | 'handoff' | 'attempted' | 'delegation'>>;
 /** A task in the run view: the plan's fields, then the status stream's. */
 type RunTask = Omit<SerializedTask, 'subtasks'> & RunTaskStatus & {
     subtasks: RunTask[];
@@ -2454,7 +2403,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, waitsForApproval?: boolean, holdReason?: string | null, completionReceived?: Verdict['reported'] | null, attaching?: 1 | 2 | null, loopStranded?: boolean): SerializedTaskStatus;
+declare function serializeTaskStatus(t: Task, idleSince?: string | null, isolation?: TaskIsolation | null, queued?: readonly QueuedTaskMessage[], awaitingApproval?: number, mergeGate?: readonly string[], checkpoint?: string, waitsForApproval?: boolean, holdReason?: string | null, completionReceived?: Verdict['reported'] | null, attaching?: 1 | 2 | null, loopStranded?: boolean, delegation?: DelegatedRow | undefined): 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;
@@ -2642,6 +2591,115 @@ declare class HostedLease implements SessionLease {
  */
 declare function processLeaseHost(): LeaseHost;
 
+/** The changes to a run in flight, as a closing Session waits them out. */
+interface RunChanges {
+    /** One is under way. */
+    readonly changing: boolean;
+    /** Every one under way has ended and none follows: nothing of this run changes git past here, so its lease can go. */
+    closeChanges(): Promise<void>;
+}
+
+/** What a Session hears from the pool of its tree. */
+interface PoolNode {
+    /** A slot freed in another Session: tick, as a Session's own events do. */
+    tick(): Promise<void>;
+    /** A slot is free for the planner turn this Session was refused: ask again now, synchronously. */
+    openTurn(): void;
+    /** Whether this Session's attempt on `taskId` waits on its planner: a question it asked, or a turn that ended without a report. */
+    waitsOnPlanner(taskId: string): boolean;
+    /** Another node found `runner`'s usage limit, which resets at `at`. */
+    limitFound(runner: string, at: Date): void;
+}
+/** What a node asks of the pool: only a role tells it what a claim takes. */
+interface SlotRequest {
+    role: 'planner' | 'task' | 'script' | 'child-plan' | 'merge';
+    taskId?: string;
+}
+/** What {@link SlotPool.take} granted. */
+interface HeldSlot {
+    /** False for a role that reserves no slot. */
+    readonly holdsSlot: boolean;
+    /** Idempotent: a slot is freed once, and offered on at once. */
+    free(): void;
+}
+/**
+ * One pool of slots across a tree (ADR-0055 D18, ADR-0058 S4), the root's and
+ * shared by every Session under it. A flat run has a pool of its own, with one
+ * node: there it is the Parallel limit over attempts alone, and it ticks nobody.
+ *
+ * A claim is synchronous and so is everything here that grants one (ADR-0029);
+ * a Session waiting on a slot in another Session is ticked from here, because a
+ * scheduler ticks only on its own Session's events.
+ */
+declare class SlotPool {
+    private readonly limit;
+    private readonly nodes;
+    private root;
+    private readonly holders;
+    /** Nodes whose subplanner turn was refused, oldest first. */
+    private readonly keptTurns;
+    /** Sessions a start was refused, oldest first. */
+    private readonly keptStarts;
+    /** The one turn past the limit: see {@link turnPasses}. */
+    private passing;
+    /** The turn being offered: out of {@link keptTurns}, so it would otherwise queue behind the turns it was chosen ahead of. */
+    private offered;
+    private offering;
+    /** Wakes the offer in flight once a slot goes: a tick's own spawn can take far longer than its claim. */
+    private taken;
+    /** When the tree was held on a usage limit, oldest first and never overlapping. */
+    private readonly holds;
+    private readonly limits;
+    constructor(limit: () => number);
+    /** Add a Session to the tree; the first is its root. Returns how it leaves. */
+    join(node: PoolNode): () => void;
+    /** The tree has a child: there is more than one Session to count across. */
+    get shared(): boolean;
+    private get counted();
+    private get full();
+    /** Why `node` may not take this now, or null. Changes nothing: a claim's refusal is also asked with no claim to follow. */
+    refusal(node: PoolNode, request: SlotRequest): string | null;
+    /**
+     * Take a slot, or be refused and kept (ADR-0059 L1): what a refusal changes
+     * is that the node is told when one frees. {@link refusal} keeps nobody, so
+     * a wait for a slot asks here even when it knows the answer.
+     */
+    take(node: PoolNode, request: SlotRequest): HeldSlot | {
+        refused: string;
+    };
+    /** An attempt's wait on its planner began or ended: the test {@link turnPasses} reads has changed. */
+    waitsChanged(): void;
+    /**
+     * `node` found `runner`'s limit (D18). Returns when it resets, the later of
+     * this and any limit a sibling found: a runner is usable only once every
+     * limit it hit has reset, and the account is the tree's. A flat run's waits
+     * stay its own.
+     */
+    limitFound(node: PoolNode, runner: string, at: Date): Date;
+    /**
+     * How long the tree has been held on a usage limit since `since`, up to each
+     * limit's reset: what a child's wall clock does not count (ADR-0056 M3). It
+     * ends at the reset whatever happens first, so what waits on a slot past it
+     * is on the clock, and limits that overlap count once.
+     */
+    heldSince(since: number): number;
+    private held;
+    /** The runners a usage limit holds across the tree. */
+    limited(): ReadonlySet<string>;
+    /**
+     * Everything that holds a slot waits on a planner, and `node`'s turn is the
+     * oldest one of them waits on: a limit that stopped the answer would stop
+     * the tree. One at a time: a turn waits on nothing (ADR-0056 M8), so when it
+     * ends this is read again, and nothing holds a slot for ever on a turn that
+     * waits for that slot.
+     */
+    private turnPasses;
+    private waitedTurn;
+    private nextTurn;
+    private offer;
+    private offerStarts;
+}
+
 /** What ran an automatic Merge all: a task reaching its merge gate, or the run settling with landed work unmerged. */
 type AutoMergeTrigger = {
     kind: 'gate';
@@ -2781,6 +2839,8 @@ interface TaskOrchestratorDeps {
     runner: IRunner;
     /** Runs script tasks' bodies (ADR-0035), in place of a registered runner. */
     scriptRunner: IRunner;
+    /** Runs delegated tasks' child plans (ADR-0055 D3). */
+    childPlanRunner: IRunner;
     store: PlanStore;
     output: TaskOutputSource;
     /** The plan's isolation run and the open run's lifecycle (ADR-0013). */
@@ -2816,8 +2876,12 @@ interface TaskOrchestratorDeps {
     isApproved: (taskId: string) => boolean;
     /** Read beside the run's setting at each automatic merge, which passes no command (ADR-0056 M6). */
     mayMergeUnasked: () => boolean;
+    /** The run's changes to git in flight; absent where no session's lease stands behind them. */
+    runChanges?: RunChanges;
     /** A read-only attempt's shell (ADR-0046); absent, its runner is given no `run_command`. */
     taskShell?: (site: TaskShellSite) => TaskShell | undefined;
+    /** Why a script that would land its work may not run unsealed now; absent at a root, whose scripts ADR-0035 answers for. */
+    unsealedRefusal?: (task: Readonly<Task>) => string | null;
     /** The session's web fetcher for one read-only attempt (ADR-0046); absent, its `fetch` and `web_search` are not available. */
     taskWebFetcher?: (task: string) => IWebFetcher | undefined;
     /** Keep a read-only attempt's saved patch beside its log (ADR-0050); absent, `save_patch` is not available. */
@@ -2827,8 +2891,47 @@ interface TaskOrchestratorDeps {
      * ran (ADR-0047). A task that ran no session, a user task, gets a log of its own.
      */
     recordHandoff: (sessionId: string | undefined, taskId: string, handoff: StoredHandoff) => void;
-    /** The session's saved task logs, which a task's `read_task` reads handoffs from (ADR-0047). */
+    /** The session's saved task logs, which a task's `read` reads handoffs from (ADR-0047). */
     taskLog: TaskLogReader;
+    /** The plans below this one (ADR-0057 R1); absent or null with nothing delegated. */
+    subtree?: () => Promise<Subtree | null>;
+    /** This plan's node in its tree, what a reference is pinned under. Absent, the root's. */
+    planNode?: () => string;
+    /** This plan's board; null for a flat plan, which has none (ADR-0057 R8). */
+    board?: () => Promise<NodeBoard | null>;
+    /** What a landing owes the tasks beside it (ADR-0057 R6); undefined where it owes nothing, as on a flat plan. */
+    landed?: (task: Readonly<Task>) => Promise<void> | undefined;
+    /** Where sessions run (ADR-0059). */
+    leases: ExecutionBackend;
+    /** The tree's slots and usage limits (ADR-0055 D18), which the backend reserves from. */
+    pool: SlotPool;
+    /** The Session's id, as it saves under it. */
+    sessionId: () => string;
+    /** Tell the tree this Session found a runner's usage limit; the reset as the tree has it. */
+    limitFound: (runner: string, at: Date) => Date;
+    /** This Session is done with the tree. */
+    leaveTree: () => void;
+    /** This node's side of the tree's ledger; absent at the root, which is charged nothing, and on a flat run, which has no ledger (ADR-0056 M5). */
+    budget?: NodeBudget;
+    /** What is ready cannot start, and nothing live will free room for it, so nothing ticks this again. */
+    startRefused: (why: string) => void;
+    /** This node's autonomy, as its mandate reads it (ADR-0056 M6). */
+    autonomous: () => boolean;
+    /** Nothing is deciding where the run goes any more; see {@link TaskOrchestrator.movesUnasked}. */
+    decided?: () => void;
+    /** Why nothing may start at this node (ADR-0055 D16, ADR-0056 M10); absent at the root, whose own Stop is its generation. */
+    nodeRefusal?: () => string | null;
+    /** The child `task` holds goes (ADR-0055 D15). Absent where no Session hosts one. */
+    discardChild?: (task: Readonly<Task>) => Promise<void>;
+}
+/** What a backend hears of the Session it serves, past the local lease it wraps. */
+interface ExecutionContext {
+    sessionId: () => string;
+    /** The root of this Session's tree: what a clean-up at the root finds a child's leavings by. */
+    treeId: () => string;
+    tell: (level: 'info' | 'warn' | 'error', text: string) => void;
+    /** What a worktree's bootstrap runs on this host, in what was last landed. */
+    setupCommand: () => string | undefined;
 }
 /**
  * What a caller supplies to {@link TaskOrchestrator.compose}; every optional
@@ -2836,17 +2939,28 @@ interface TaskOrchestratorDeps {
  * resolved wiring the orchestrator itself runs on.
  */
 interface TaskOrchestratorOptions {
+    /** The plans below this one (ADR-0057 R1); absent or null with nothing delegated. */
+    subtree?: () => Promise<Subtree | null>;
+    /** This plan's node in its tree, what a reference is pinned under. Absent, the root's. */
+    planNode?: () => string;
+    /** This plan's board; null for a flat plan, which has none (ADR-0057 R8). */
+    board?: () => Promise<NodeBoard | null>;
+    /** What a landing owes the tasks beside it (ADR-0057 R6); undefined where it owes nothing, as on a flat plan. */
+    landed?: (task: Readonly<Task>) => Promise<void> | undefined;
     /** What starting a research task owes the planner (ADR-0037 R3). */
     research?: Pick<ResearchTasks, 'started'>;
     config: IConfig;
     notifications: INotification;
     runner: IRunner;
     scriptRunner?: IRunner;
+    childPlanRunner?: IRunner;
     store?: PlanStore;
     output?: TaskOutputSource;
     isolation?: IWorktreeIsolation;
     registry?: RunnerRegistry | null;
     workspaceRoot?: () => string;
+    /** A child session's state root (ADR-0055 D11); absent on a flat run, whose workspace is both roots. */
+    stateRoot?: string;
     workspaceEnv?: (cwd: string) => Promise<WorkspaceEnv>;
     skillsAt?: (roots: readonly string[]) => SkillLookup;
     previousAttemptFromLog?: (taskId: string) => string | null;
@@ -2860,6 +2974,8 @@ interface TaskOrchestratorOptions {
     /** Whether this node's mandate lets an automatic merge run; true unless set. */
     mayMergeUnasked?: () => boolean;
     taskShell?: (site: TaskShellSite) => TaskShell | undefined;
+    /** See {@link TaskOrchestratorDeps.unsealedRefusal}. */
+    unsealedRefusal?: (task: Readonly<Task>) => string | null;
     taskWebFetcher?: (task: string) => IWebFetcher | undefined;
     keepPatch?: (taskId: string, attempt: number, patch: Buffer) => string;
     recordHandoff?: (sessionId: string | undefined, taskId: string, handoff: StoredHandoff) => void;
@@ -2869,6 +2985,30 @@ interface TaskOrchestratorOptions {
      * to the run (ADR-0049); the run is changed only while it answers null.
      */
     sessionHeld?: () => SessionHeld | null;
+    /** Where sessions run (ADR-0059), given the local worktrees: those, unless the `containers` setting or a test supplies another. */
+    execution?: (local: ExecutionBackend, context: ExecutionContext) => ExecutionBackend;
+    /** The root's pool, handed down to a child (ADR-0055 D18); absent, this is a root, with a pool of its own. */
+    pool?: SlotPool;
+    /** The Session's id, as it saves under it. */
+    sessionId?: () => string;
+    /** Its tree's root's, when it is a child; absent, it is a root. */
+    treeId?: () => string;
+    /** The pool has a slot for the planner turn it refused this Session. */
+    openTurn?: () => void;
+    /** A child's side of the tree's ledger (ADR-0056 M5). */
+    budget?: NodeBudget;
+    /** What follows a start its budget refuses with nothing live; the node stops, unless a subplanner can ask. */
+    startRefused?: (why: string) => void;
+    /** This node's autonomy, as its mandate reads it (ADR-0056 M6); the config's, at a root. */
+    autonomous?: () => boolean;
+    /** Nothing is deciding where the run goes any more. */
+    decided?: () => void;
+    /** What this node's ancestors protect (ADR-0056 M4). */
+    inheritedProtectedPaths?: () => readonly string[];
+    /** See {@link TaskOrchestratorDeps.nodeRefusal}. */
+    nodeRefusal?: () => string | null;
+    /** See {@link TaskOrchestratorDeps.discardChild}. */
+    discardChild?: (task: Readonly<Task>) => Promise<void>;
 }
 /**
  * The pure scheduler. Owns execution state (the {@link RunState},
@@ -2883,6 +3023,7 @@ interface TaskOrchestratorOptions {
  * and does not unblock dependent work.
  */
 declare class TaskOrchestrator {
+    private readonly deps;
     private config;
     private notifications;
     private store;
@@ -2902,6 +3043,10 @@ declare class TaskOrchestrator {
     private admissions;
     private reviewApproved;
     private autoMergeBlocked;
+    /** Ticks and attempt ends under way; see {@link deciding}. */
+    private decisions;
+    /** The run closed with its merge held, which it would otherwise have made itself. */
+    private mergeOwedAtClose;
     private mergesInFlight;
     private retryCounts;
     /** A Merge all is under way: no ops task starts until it ends (ADR-0020). */
@@ -2940,6 +3085,8 @@ declare class TaskOrchestrator {
      * by its body stays here, so a retry of that task resumes it (L7).
      */
     private readonly carriedLoops;
+    /** The checks of a delegated task that passed with no scheduler to start them (ADR-0055 D8): carried as a loop is, never queued, since one that stops being ready simply stops being owed. */
+    private readonly carriedChecks;
     /** What was last said of a carried loop's approvals, so it is said once. */
     private loopNotice;
     /**
@@ -2953,6 +3100,13 @@ declare class TaskOrchestrator {
     private releasing;
     /** Tasks paused on a usage limit, the run's hold on them, and each runner's wait for its reset (ADR-0018, U1). */
     private readonly limitPauses;
+    /**
+     * Resumes whose reset came with every slot of the tree taken: past their
+     * time, with no timer to fire again, so a tick offers them (ADR-0055 D18).
+     */
+    private readonly keptResumes;
+    /** What a close waits out past the runners: ticks, attempt ends, and work nothing awaits, a Stop's release of a worktree chiefly. */
+    private readonly loose;
     /**
      * The plan's isolation run and the open run's lifecycle (ADR-0013); see
      * {@link IsolationRunController}. Read and acted on there directly, except
@@ -2960,6 +3114,11 @@ declare class TaskOrchestrator {
      * ops tasks and starts the tasks its merge lets through.
      */
     readonly runs: IsolationRunController;
+    /** Where a session runs (ADR-0059): every start reserves here in its claim, and opens here after it. */
+    private readonly leases;
+    /** The tree's slots and usage limits (ADR-0055 D18); a flat run's own. */
+    private readonly pool;
+    private readonly sessionId;
     /** A passed attempt's work onto the integration branch, and the conflict repair a landing may need. */
     private landing;
     private observers;
@@ -2985,12 +3144,14 @@ declare class TaskOrchestrator {
     /** 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;
-    approveCheckpoint(taskId: string): void;
+    approveCheckpoint(taskId: string, note?: 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;
     /** Whether the task waits at a checkpoint its live attempt can still answer. */
     awaitsCheckpoint(taskId: string): boolean;
+    /** A line from Ordewell to a running task (ADR-0057 R6); false where nothing is running. */
+    addressTask(taskId: string, line: 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
@@ -3070,8 +3231,9 @@ declare class TaskOrchestrator {
      * admitted and not yet claimed, a force start queued behind its
      * dependencies, a conflict repair owed a slot or the end of a start hold,
      * a task that resumes on its own at its usage limit's reset, a start a
-     * dirty checkout parked for Stash and continue to replay, or a loop carried
-     * on with no scheduler. A Stop is owed to it, whether or not anything runs.
+     * dirty checkout parked for Stash and continue to replay, or a loop or a
+     * delegated task's check carried on with no scheduler. A Stop is owed to it,
+     * whether or not anything runs.
      * A carried loop a body task stopped starts nothing, so it is not here: see
      * {@link loopCarried}.
      */
@@ -3121,6 +3283,8 @@ declare class TaskOrchestrator {
      * over as before.
      */
     private closeRun;
+    /** A hold is no merge that stopped (ADR-0055 D9): the tick after its check's pass or Skip merges, the run closed or not. */
+    private mergeOwedAfterHold;
     /**
      * Whether closing the run merges what landed, with nobody asked. The run
      * says it has ended before it closes, and a list read in between must not
@@ -3159,6 +3323,13 @@ declare class TaskOrchestrator {
      */
     judgingOnce<T>(read: () => T): T;
     private startRule;
+    /** What tells a check, which reads the runners' modes as an attempt's kind does (ADR-0031). */
+    private get checkRules();
+    private liveCheck;
+    /** A retry takes the task's checks back, and a live one cannot be (ADR-0055 D8). */
+    private refuseBesideLiveCheck;
+    /** What holds every merge but the user's (ADR-0055 D9), named as a refusal names it. */
+    get mergeHold(): readonly Task[];
     /**
      * Why no resolver may be added to this task's conflict now, or null: a
      * conflict has one worker (ADR-0015), so a repair or a resolver that has it
@@ -3338,6 +3509,8 @@ declare class TaskOrchestrator {
      * came from, which a repair follows on from.
      */
     private applyLanding;
+    /** Before anything the landing lets start: what a dependent reads of it should be there (ADR-0057 R6). A flat plan owes nothing, and waits on nothing. */
+    private owedByLanding;
     /**
      * 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
@@ -3360,6 +3533,8 @@ declare class TaskOrchestrator {
     private retireResolver;
     /** A planner's remove reaches no {@link releaseTask}: what it took out of the plan since `before` ends its conflicts here. */
     private retireResolversLeft;
+    /** A delegated task the edit took out leaves nothing naming its child's run, so that goes with it, once a child still stopping has (ADR-0055 D15). */
+    private retireChildrenLeft;
     /** A control that would end a conflict waits for the resolver at work on it: a conflict has one worker (ADR-0015). */
     private refuseBesideResolver;
     private landResolved;
@@ -3615,7 +3790,49 @@ declare class TaskOrchestrator {
      * still under way read as `dependencies` rather than `queued`.
      */
     private holdsQueued;
+    /**
+     * Whether a start nobody asked for has to wait for a slot, wherever in the
+     * tree they are held. Asked with no claim to follow, so it reserves to be
+     * refused: the refusal is what has a slot freed elsewhere tick this Session
+     * (ADR-0059 L1).
+     */
     private slotsFull;
+    /** The kept resumes the tree has room for now. A Stop or a retry since has cancelled the rest. */
+    private offerKeptResumes;
+    /** A pool's tick: it has nobody to tell of a failure, so it is said. */
+    offered(): Promise<void>;
+    /** The task's live attempt holds a slot: every one does but a delegated task's (ADR-0055 D18). */
+    holdsSlot(taskId: string): boolean;
+    /** The task's live attempt waits on this Session's planner: what lets a turn pass the limit (ADR-0055 D18). */
+    waitsOnPlanner(taskId: string): boolean;
+    /** A subplanner's turn found its runner's limit, the account's and so the tree's (ADR-0055 D18). */
+    plannerLimited(runner: string, at: Date): void;
+    limitFoundElsewhere(runner: string, at: Date): void;
+    /** A planner turn's lease (ADR-0059 L1): a subplanner's waits its turn for a slot, and a root's is never held (ADR-0055 D18). */
+    reserveTurn(): {
+        lease: ReservedLease;
+    } | {
+        refused: string;
+    };
+    /** The tree's pool, which a child joins (ADR-0055 D18). */
+    get slotPool(): SlotPool;
+    /** A runner let go for the task has not gone yet. */
+    windingDown(taskId: string): boolean;
+    /** Every runner this Session let go has gone. */
+    woundDown(): Promise<void>;
+    /** Nothing the run started is still going, so a close has nothing to wait for. */
+    get leftNothing(): boolean;
+    /** Every runner let go has gone, with what a Stop left to end after it and whatever a backend had running past one, and the run changes git no more. What a next attempt comes back to stays. */
+    allGone(): Promise<void>;
+    /** The Session is closing: the tree stops counting on it. */
+    leaveTree(): void;
+    /** What the run left past its worktrees, as a Clean up gives it up (ADR-0059 L6). */
+    reclaimLeases(): Promise<void>;
+    private leaseRequest;
+    /** What a start of `task` reserves: a delegated task takes a node and no slot, or a parent at its limit deadlocks on the children that need them (ADR-0055 D18). */
+    /** Whether a start of `task` is its child plan's: a delegated task's repair is a plain runner's, which holds a slot and spends tokens (ADR-0055 D14). */
+    private startsChildPlan;
+    private attemptRequest;
     private sayQueuedAtGate;
     /** A start asked for under the whole rule that the rule holds back, in words the user can act on; a turn's hold ends by itself. */
     private sayQueuedHeld;
@@ -3633,6 +3850,27 @@ declare class TaskOrchestrator {
     isAnyFailed(): boolean;
     approveReview(origin?: RunOrigin): Promise<void>;
     tick(): Promise<void>;
+    /**
+     * A tick or an attempt's end is under way, so the run may yet go on or end,
+     * and tell its supervisor which. A child read in that gap has neither, and
+     * would be taken for one that sits on nothing (ADR-0056 M8). Only a child is
+     * read that way, so a flat run's ticks take the turns they always took. A
+     * close waits one out, at any level: its next step may be a release.
+     */
+    private deciding;
+    /** `work`, unchanged, as a close waits for it. */
+    private underWay;
+    private ticked;
+    /** Why what is ready cannot start, with nothing live to free room for it: no event will tick this again (ADR-0056 M5). Null otherwise. */
+    get refusedStart(): string | null;
+    /**
+     * The run moves with nobody asked: something is at work, a reset resumes it,
+     * or a slot elsewhere in the tree starts what is ready (ADR-0055 D18). What
+     * tells a child that sits on nothing from one that waits (ADR-0056 M8).
+     */
+    get movesUnasked(): boolean;
+    /** What is ready now, for a reader that asks far more often than a tick does, so it logs nothing. */
+    private readyNow;
     /** One of a tick's starters: takes the next of `waiting` as each start it made has attached. */
     private startReady;
     /**
@@ -3646,6 +3884,13 @@ declare class TaskOrchestrator {
      * as a scheduled one is held, on whatever the start rule waits for.
      */
     private settleRun;
+    /**
+     * What holds this run back is another Session's, not the user's: a slot, or a
+     * usage limit a sibling found. Nothing here will tick for it, and what frees
+     * it does, so no child parks waiting on a user (ADR-0055 D18). A flat run has
+     * no such wait: an idle Session of one has its slots free.
+     */
+    private waitsOnTree;
     private waitOnUser;
     /**
      * A loop's check failed (ADR-0045). With `failed` evidence and rounds left,
@@ -3683,8 +3928,10 @@ declare class TaskOrchestrator {
     private ownsNextRound;
     /** A check between rounds that nothing will run: it waits on a person, its failure no longer one its loop answers (ADR-0045 L5, ADR-0053). */
     loopStranded(taskId: string): boolean;
-    /** A tick starts something: the scheduler the plan, or the loops carried on, their tasks alone. */
+    /** A tick starts something: the scheduler the plan, or what is carried on, those tasks alone. */
     private get startsOnTick();
+    /** What is owed with no scheduler: the loops carried on, and the checks of a delegated task that ended. */
+    private carriedOn;
     /**
      * The carried loops with work owed now: a check between rounds whose loop
      * goes on, or a round waiting to start. None under a scheduler, which owes
@@ -3692,17 +3939,29 @@ declare class TaskOrchestrator {
      * One a body task stopped is not here until that task passes (L7).
      */
     private loopsCarriedOn;
+    /**
+     * The checks of a delegated task that ended, ready to start. Whatever start
+     * ended it, a run with no scheduler would otherwise close under them with
+     * their merge still held (ADR-0055 D8, D9). None under a scheduler, which
+     * owes them itself, or while a usage limit holds the run. One behind a
+     * failure or other unfinished work is not here: nothing is moving towards it.
+     */
+    private checksCarriedOn;
+    /** A delegated task passed, and nothing scheduled follows it. A Stop since the start that landed it leaves its checks where they are: a resolver's landing outlives one, with this task waiting on the user and no attempt to stop. */
+    private carryChecks;
     /**
      * The run that carried them is over, by a Stop or by what gives the run up
      * or clears it up: a retry of a body task that passes runs that task alone.
      */
     private endCarriedLoops;
-    /** What a tick may start with no scheduler: the loops carried on, and nothing that depends on them. */
+    /** What a tick may start with no scheduler: what is carried on, and nothing that depends on it. */
     carriedTasks(): Set<string>;
     /**
-     * A task of a carried loop outside the user's approval record waits as any
-     * does (ADR-0045, Consent). Said here, once, as well as listed: a run they
-     * started one task of says nothing else of why the loop's next step does not come.
+     * A carried task outside the user's approval record waits as any does
+     * (ADR-0045, Consent): starting a delegated task consents to that task alone,
+     * and a script check's consent is to its body (ADR-0035). Said here, once, as
+     * well as listed: a run they started one task of says nothing else of why the
+     * next step does not come.
      */
     private sayUnapprovedInLoop;
     /** Skipped work is not completed work, so a run with any says so rather than that everything completed. */
@@ -3719,16 +3978,23 @@ declare class TaskOrchestrator {
     /**
      * 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 left the plan or is being
-     * marked complete, a resolver has its conflict, so a start of it would be a
+     * marked complete, this node may start nothing (ADR-0055 D16, ADR-0056 M10), a resolver has its conflict, so a start of it would be a
      * second worker on it (ADR-0015), a revert is taking back work it depends on
      * or skipped it since (ADR-0054), it
-     * 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. `revives` is a start asked of a
-     * task already skipped, as a force start or a continue may be: only that runs
-     * one again. A retry has made it pending by the time it claims.
+     * is outside the user's approval record (ADR-0035), its node's budget has no
+     * room for it (ADR-0056 M5), or its lease cannot be
+     * reserved, every slot being taken (ADR-0059 L1). Read in the same
+     * synchronous step as the claim it guards, so nothing can change in between.
      */
     private claimRefusal;
+    /**
+     * All of {@link claimRefusal} short of the lease: what a refusal keeps nobody
+     * for. Whatever else a start spends is checked here, since every attempt
+     * passes it. `revives` is a start asked of a task already skipped, as a force
+     * start or a continue may be: only that runs one again. A retry has made it
+     * pending by the time it claims.
+     */
+    private startRefusal;
     /** 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. */
@@ -3736,8 +4002,10 @@ declare class TaskOrchestrator {
     /**
      * 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 {@link Attempts.start}), so
-     * no other start can take the same task or slot.
+     * synchronous step ({@link startRefusal}, the lease's `reserve`, then
+     * {@link Attempts.start}), so no other start can take the same task or slot.
+     * `reserve` rather than `refusal` answers for the slot, since being turned
+     * down is what keeps this Session for the slot that frees (ADR-0059 L1).
      * The task is read here, as it stands: a start that awaited first — its run
      * opening, the user's answer — runs what the plan holds now, not what it
      * held when it was asked for. A task already claimed is not claimed again:
@@ -3755,191 +4023,6 @@ declare class TaskOrchestrator {
     continueBlockedRun(how: 'stash' | 'shared' | 'reread'): Promise<void>;
 }
 
-/**
- * The effect allowlist (ADR-0035): the user's standing approval for named
- * effects, beside the planner allowlist, which names reads. It pre-approves a
- * script task whose `commands` are all covered; it never covers a `script`
- * body, whose shell text no rule can be matched against.
- *
- * A rule is matched against the whole command, every word in order and flags
- * included, because an effect's flags change what it does: `git push origin
- * feature/*` covers `git push origin feature/login`, never the same push with
- * `--force`. `*` stands for one word, or inside a word for any run of
- * characters, as in the planner allowlist, except that it never stands for
- * what changes the effect: a flag (`--force`, and `/force` on Windows), a
- * refspec's force or delete (`+main`, `:main`), or a `:` outside a URL
- * (`feature/x:main`, which pushes to `main`). The rule writes any of those
- * itself. A rule spells out its operation before any `*`, so
- * `az webapp config * set` is no rule at all.
- *
- * Exclusions are the planner allowlist's `!` entries, with any `!` entry
- * written here; an exclusion wins. A command exclusion is matched as the
- * planner allowlist matches it; a path or URL exclusion holds for an argument
- * that names an absolute path or URL it covers, whole or after a `=`, `@`,
- * `:` or `,` or a short flag (`--url=…`, `-d @…`). A relative path is not
- * resolved, since the body does not say where it runs. A program named by its
- * path is a file the repository ships (ADR-0026), so it is never covered.
- * There are no built-in rules: a default would pre-approve an effect the user
- * never chose.
- */
-interface EffectRule {
-    text: string;
-    binary: string;
-    words: RuleWord[];
-}
-interface EffectRules {
-    rules: EffectRule[];
-    exclusions: PlannerAllowlist;
-    platform: NodeJS.Platform;
-    /** The entries that are no rule, each with the warning that says why it is ignored. */
-    ignored: {
-        rule: string;
-        warning: string;
-    }[];
-}
-/**
- * `entries` are the effect allowlist's; `plannerEntries` the planner allowlist
- * in force, whose `!` entries hold here too; `platform` the one the commands
- * run on, which decides how a flag is spelled and how a path resolves.
- */
-declare function parseEffectAllowlist(entries: readonly string[], plannerEntries?: readonly string[], platform?: NodeJS.Platform): EffectRules;
-/**
- * The rules, by name, that cover every command of a `commands` body, or null
- * when one command is not covered, an exclusion holds for one, or the body is
- * a `script`.
- */
-declare function effectRuleFor(list: EffectRules, body: ScriptBody): string | null;
-
-/**
- * The mandate (ADR-0056): what a node may do without a person, and within what
- * limits. The root's is derived on each read from today's settings and never
- * saved; a child's is one pure function of its parent's and its request, which
- * can only narrow what the parent may hand on. Authority only: capability stays
- * at the boundary a session runs in, and a prompt enforces nothing.
- */
-declare const GRANTS: readonly ["observe", "steer", "control", "replan", "approve", "delegate", "effect", "research", "merge"];
-/** Each is a set of things a node may do unasked (M2). */
-type Grant = (typeof GRANTS)[number];
-/** What a mandate could not finish without: a child holds these unasked, and `narrow` refuses one that would lack any (M2). */
-declare const FLOOR_GRANTS: readonly Grant[];
-/** The shape of a tree, by ADR-0055 D19: refused past the hard cap, never dropped. */
-declare const SHAPE_LIMITS: {
-    readonly depth: {
-        readonly default: 2;
-        readonly hard: 4;
-    };
-    readonly delegatedTasks: {
-        readonly default: 8;
-        readonly hard: 30;
-    };
-    readonly tasksPerPlan: {
-        readonly default: 30;
-        readonly hard: 100;
-    };
-};
-interface MandateLimits {
-    /** The node's token budget; the root's is the tree's, from the delegation setting (M3, M5). */
-    tokens: number;
-    /** Null: no limit, which only the root has. */
-    wallClockMs: number | null;
-    /** How many levels may still open below this node. */
-    depth: number;
-    delegatedTasks: number;
-    tasksPerPlan: number;
-    runners: readonly RunnerId[];
-    /** The models a runner is held to; a runner not named may use any it offers, as the user's allowlist reads. */
-    models: Readonly<Record<RunnerId, readonly string[]>>;
-}
-interface MandateExclusions {
-    protectedPaths: readonly string[];
-}
-interface Mandate {
-    /** What this node may do. */
-    grants: ReadonlySet<Grant>;
-    /** What it may hand a child. */
-    grantable: ReadonlySet<Grant>;
-    /** Read in place of the global level. */
-    autonomy: 'full' | 'guarded';
-    limits: MandateLimits;
-    /** These only accumulate. */
-    exclusions: MandateExclusions;
-    /** One per level, each with its own `!` rules: a command must match at every level (M4). */
-    effectRules: readonly EffectRules[];
-}
-/** What the root's mandate is read from, each where it lives today (M1). */
-interface RootSettings {
-    /** The run's own copy: where a guard or a failure lowers it, and the user's change lands. */
-    level: SupervisorLevel;
-    autorun: boolean;
-    autonomous: boolean;
-    /** The tree's budget; 0 is delegation off (ADR-0055 D21). */
-    delegationTokens: number;
-    /** The effect allowlist, absent where nothing was read. */
-    effects?: EffectRules;
-    runners: readonly RunnerId[];
-    models: Readonly<Record<RunnerId, readonly string[]>>;
-}
-/** What a delegated task asks of the mandate it is given. `grants` names what it asks for past the floor; absent asks for nothing. */
-interface MandateRequest {
-    /** The level of the node narrowing, the root being 0: the one a refusal names. */
-    level: number;
-    grants?: readonly Grant[];
-    autonomy?: Mandate['autonomy'];
-    /** A delegated task must carry one (M5). */
-    tokens?: number;
-    wallClockMs?: number;
-    depth?: number;
-    delegatedTasks?: number;
-    tasksPerPlan?: number;
-    runners?: readonly RunnerId[];
-    models?: Readonly<Record<RunnerId, readonly string[]>>;
-    protectedPaths?: readonly string[];
-    effectRules?: EffectRules;
-}
-interface MandateRefusal {
-    level: number;
-    field: string;
-    asked: string;
-    there: string;
-}
-type Narrowed = {
-    ok: true;
-    mandate: Mandate;
-} | {
-    ok: false;
-    refusal: MandateRefusal;
-};
-declare function mandateRefusalText({ level, field, asked, there }: MandateRefusal): string;
-/**
- * The root's mandate, as it stands now (M1): built afresh on each read, so an
- * Act that a guard lowered reads Watch at the next check, and nothing saved
- * could disagree with the settings.
- */
-declare function rootMandate(settings: RootSettings): Mandate;
-/**
- * What holds at a node now (M1): its saved mandate within every ancestor's
- * `grantable` as it stands, so a change at the root reaches the subtree at the
- * next check. This reading intersects and refuses nothing: the floor binds
- * {@link narrow}, which writes a new child, not this.
- */
-declare function heldMandate(saved: Mandate, ancestors: readonly Mandate[]): Mandate;
-/**
- * A child's mandate (M4), or the refusal that names the level that refused,
- * the field, what was asked and what is there. Pure, and written to be proved:
- * no result is wider than its parent. `parent.limits.tokens` and `wallClockMs`
- * are what the parent has left, which is the caller's to read.
- */
-declare function narrow(parent: Mandate, request: MandateRequest): Narrowed;
-/** What a node reads of its own authority, at each check (M1). */
-interface NodeAuthority {
-    /** How far below the root, which is 0 and where a person remains. */
-    readonly depth: number;
-    /** The mandate that holds now. `level` is what the root's is read at; a child's does not depend on it. */
-    mandate(level: SupervisorLevel): Mandate;
-}
-/** The root: its settings read as each check asks, the level included, which each caller names. */
-declare function rootAuthority(settings: () => Omit<RootSettings, 'level'>): NodeAuthority;
-
 /** One call at the command seam, as every route words it (ADR-0029). Task references are resolved here. */
 type ExecutionCommand = {
     command: 'run_plan';
@@ -3981,6 +4064,7 @@ type ExecutionCommand = {
 /** Merge all: the run's landed work into the user's branch (ADR-0013). */
  | {
     command: 'merge_all';
+    pastChecks?: true;
 }
 /** End a task as skipped: nothing it did lands, and its dependents go ahead without it once the work it waited on is done. `reason` is required of anyone but the user. */
  | {
@@ -4057,6 +4141,7 @@ type ExecutionCommand = {
     task: string;
     answer: 'approve' | 'reject';
     reason?: string;
+    raiseTokens?: number;
 }
 /** The user signs off the plan's review: every task in it is approved, as executing it approves them, and it runs. */
  | {
@@ -4103,6 +4188,11 @@ type CommandPayload =
  | {
     kind: 'revert';
     result: IsolationRevertResult;
+}
+/** The user's `merge_all` asked first: what it would merge past are these checks, named as the plan names them, and `pastChecks` is the yes (ADR-0055 D9). */
+ | {
+    kind: 'merge_hold';
+    checks: string[];
 };
 /**
  * What a call came to: `message` is written for the caller, a model included,
@@ -4194,11 +4284,15 @@ interface ExecutionHost {
     admitStart(): StartAdmission;
     /** The task's attempt is live: starting, running or landing. */
     running(taskId: string): boolean;
+    /** Its live attempt holds a slot, as a delegated task's does not (ADR-0055 D18). */
+    holdsSlot(taskId: string): boolean;
     /** A conflict repair of the task will start by itself: there is a start to withdraw (ADR-0015). */
     repairOwed(taskId: string): boolean;
     maxParallel(): number;
     /** The run waits on the user to stash or skip isolation before anything starts. */
     runBlocked(): boolean;
+    /** Why nothing may start here, as every surface says it: another host holds the session (ADR-0049). */
+    heldRefusal(): string | null;
     /**
      * Every reason the task cannot start now, from the scheduler's one start
      * rule (ADR-0034). Takes the task, not its id: the one the seam located.
@@ -4236,6 +4330,8 @@ interface ExecutionHost {
     /** A start cleared its last check and is about to act; the user's ends their Stop (ADR-0029). */
     startAsked(actor: ExecutionActor): void;
     retryTask(taskId: string, actor: ExecutionActor): Promise<void>;
+    /** Whether the task is a delegated task's check (ADR-0055 D8). */
+    checksDelegatedTask(taskId: string): boolean;
     /** End the task as skipped, landing nothing of it; see {@link TaskOrchestrator.skipTask}. */
     skipTask(taskId: string, reason: string | undefined, actor: ExecutionActor): Promise<void>;
     continueTask(taskId: string, message: string, actor: ExecutionActor): Promise<void>;
@@ -4252,7 +4348,11 @@ interface ExecutionHost {
     cancelResume(taskId: string): Promise<boolean>;
     /** The task waits at a checkpoint, and a runner is left to hear the answer. */
     awaitsCheckpoint(taskId: string): boolean;
-    answerCheckpoint(taskId: string, approve: boolean, reason?: string): void;
+    answerCheckpoint(taskId: string, approve: boolean, reason?: string, note?: string): void;
+    /** The checks that hold every merge but the user's (ADR-0055 D9), each as its row names it. */
+    mergeHold(): readonly string[];
+    /** A raise for a delegated task's child, from what this node has left (ADR-0056 M5). Null when it took; otherwise why not. */
+    raiseChild(taskId: string, tokens: number): Promise<string | null>;
     /** Sign off the review: the plan is the user's, and runs. */
     approveReview(): Promise<void>;
     /** Answer a runner's request, as its card does; false once it was answered or withdrawn. */
@@ -4354,7 +4454,7 @@ declare class ExecutionCommands {
      * it, and the supervisor keeps its own tools. `confirmed` is the user's yes to
      * an option's `confirm`, which a choice cannot imply.
      */
-    answerEscalation(id: string, option: string, note?: string, confirmed?: boolean): Promise<CommandOutcome>;
+    answerEscalation(id: string, option: string, note?: string, confirmed?: boolean, raiseTokens?: number): Promise<CommandOutcome>;
     /** A valid, consented call, from the user's answer where one is needed to the act and its record. */
     private carryOut;
     /**
@@ -4377,8 +4477,9 @@ declare class ExecutionCommands {
     private startScript;
     /**
      * Why a script task cannot start as `run_script` would start it, but for its
-     * merge gate, at which it waits: a dependency that failed or has not
-     * finished, a Merge all under way, every slot taken. Null when it can.
+     * merge gate, at which it waits: another host holding the session, a
+     * dependency that failed or has not finished, a Merge all under way, every
+     * slot taken. Null when it can.
      */
     private scriptUnready;
     /**
@@ -4731,6 +4832,18 @@ interface PlanChangeScope {
     catalog(runners: RunnerId[]): AssignmentCatalog & {
         runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     };
+    /**
+     * The node a change is made on, with what it holds now and how far below the
+     * root it stands, read as each check runs (ADR-0056 M4). Absent or undefined,
+     * nothing may delegate: a one-shot planner has no node, and a build that does
+     * not offer delegation reads no mandate for it.
+     */
+    node?(): {
+        mandate: Mandate;
+        level: number;
+    } | undefined;
+    /** Whether a script can run sealed here (ADR-0036 S6): a change that brings a read-only one waits on this, as an attached skill waits on its lookup. */
+    canSeal?(): Promise<boolean>;
     /** Where attached skill names are looked up; absent, none are. */
     skills?(): SkillLookup;
     /** The handles the open turn's committed edits gave, each with its task's id, for a later batch to name them by (ADR-0022 P2). */
@@ -4771,12 +4884,41 @@ declare class PlanChangeCheck {
     checkNow<P extends CheckPhase>(change: PlannerChange<P>, phase: P): CheckedChange;
     /** A plan's JSON read into tasks as it is submitted; nothing in it reads the plan. */
     private read;
+    /** Whether this node may write a delegated task: read on every route, since a parse that took one anyway would only be refused later (ADR-0055 D21). */
+    private delegation;
+    /** Only such a change waits on the probe, so a flat plan's check takes the turns it always took. */
+    private bringsSealedScript;
     private rules;
     /** What a child's mandate leaves out of this change: `replan` for any, and `research` for a research task it brings. */
     private ungranted;
+    /**
+     * What a change leaves past this node's limits (ADR-0055 D2, D19): each
+     * delegated task it wrote narrowed as it is written (ADR-0056 M4), so a plan
+     * never holds what its carve would refuse, and a child held to what a child
+     * plan may be. Only what this change wrote: what stands in the plan is not
+     * this edit's to answer for. A root plan has no task limit, so a flat run
+     * does not change.
+     */
+    private pastMandate;
     private refused;
 }
 
+/** What a planner that may delegate is told of its limits (ADR-0055 D19). */
+interface PlannerDelegation {
+    tokens: number;
+    delegatedTasks: number;
+    /** What a delegated task of this plan can ask for past the floor. */
+    grantable: readonly string[];
+}
+/** What a subplanner is told of what it was given (ADR-0055 D4). */
+interface SubplannerBrief {
+    /** Its own and its ancestors': a change to one fails its verdict (D7). */
+    protectedPaths: readonly string[];
+    readOnly: boolean;
+    /** The runner it plans on. */
+    runner: RunnerId;
+}
+
 /**
  * How much of its model's window an API planner's next call may fill. The
  * check runs before every call, against the model configured at that moment,
@@ -4865,6 +5007,8 @@ interface CliAgentAiServiceDeps extends Partial<AgentProcessDeps> {
     projectServerApprovals?: ProjectServerApprovals;
     /** What the planner is shown of its context and budgets at the start of each turn. */
     turnBudgets?: TurnBudgets;
+    /** Open the execution lease of the turn a process starts for (ADR-0059 L1); absent, it runs at `workspaceRoot`. */
+    openLease?: (signal: AbortSignal) => Promise<OpenLease> | undefined;
 }
 /**
  * A coding agent driven as Ordewell's planner (ADR-0009).
@@ -4891,6 +5035,7 @@ declare class CliAgentAiService implements IAiService {
     private readonly mcpServer;
     private readonly turnBudgets;
     private readonly projectServerApprovals;
+    private readonly openLease;
     private activeAbort;
     /** See {@link compactions}. */
     private compacted;
@@ -5087,6 +5232,14 @@ interface PlannerToolsOffer {
     /** The tools a child's grants leave out of its list, fixed as its session starts (ADR-0056 M6); the root's list is not filtered. */
     withheld?: readonly string[];
     handler: PlannerToolHandler;
+    /** Its `submit_plan` takes a delegated task (ADR-0055 D1). */
+    delegates?: boolean;
+    /** A subplanner's: its token serves `task_complete` and `checkpoint` too, for the handler's `taskComplete` and `checkpoint` (D5). */
+    subplanner?: boolean;
+    /** Its harness's own subagents are withheld: nothing refuses what they spend, so a subplanner has them only with `research` (ADR-0056 M6). */
+    noSubagents?: true;
+    /** What a subplanner's process loads of the user's setup: its tasks' setting holds for it too (ADR-0057 R11). */
+    runnerConfig?: TaskRunnerConfig;
 }
 /**
  * Everything the conversation loop needs to start planning (ADR-0002).
@@ -5127,6 +5280,10 @@ interface ConversationRequest {
      */
     initialMessage?: string;
     plannerTools?: PlannerToolsOffer;
+    /** Teaches the planner delegation, only where its mandate holds `delegate` (ADR-0055 D21). */
+    delegation?: PlannerDelegation;
+    /** The prompt is a subplanner's, whose parent stands where the user does (ADR-0055 D4). */
+    subplanner?: SubplannerBrief;
     /**
      * The session's notice channel, for a warning the planner's surface should
      * show once (ADR-0036 N4: the native-shell setting is on but the harness is
@@ -5539,6 +5696,8 @@ interface PlannerConversationHost {
     goal(): string;
     aiService(): IAiService;
     onProgress(progress: ResearchProgress): void;
+    /** The planner is a subplanner: its prompt told it the catalog, and a plan that has settled leaves it only its report (ADR-0057 R11). */
+    subplanner?(): boolean;
     /** Fresh discovery, allowlist-filtered the way the system prompt shows it. */
     opening(runners: RunnerId[]): Promise<ConversationOpening>;
     /** What the per-turn catalog block and every read draw from, as of now. */
@@ -5581,10 +5740,12 @@ interface PlannerConversationHost {
     capturePrd(text: string): void;
     /** The planner turn was stopped or abandoned: whatever it is waiting on (a parked approval) will never be answered. */
     turnAborted(): void;
-    /** A planner turn is about to take the conversation, which nothing holds now. */
+    /** A planner turn is about to take the conversation, which nothing holds now. Throws why it may not. */
     turnClaiming?(): void;
     /** A planner turn let the conversation go, so the next one may take it. */
     turnReleased?(): void;
+    /** A turn was let go without ending: abandoned with its plan, or hung. */
+    turnDropped?(): void;
     /**
      * A turn ended on the planner's usage limit, which it reported as `said`:
      * what is sent again, and when. `answered`: a planner tool's change in the
@@ -5712,6 +5873,7 @@ declare class PlannerConversation {
     private readonly briefing;
     private readonly blocks;
     private live;
+    private readonly idling;
     private openTurn;
     /** When the live context's newest turn opened; null with no live context. */
     private requestedAt;
@@ -5733,10 +5895,14 @@ declare class PlannerConversation {
     get lastRequestAt(): number | null;
     /** Whether a planner turn holds the conversation. */
     get isTurnInFlight(): boolean;
+    /** Resolves once no turn holds the conversation: what a subtree's stop waits on (ADR-0055 D16). */
+    idle(): Promise<void>;
+    private settleIdle;
     /** Stop the planner turn in flight; it settles as stopped. False when none is. */
     stopTurn(by?: 'force_send'): boolean;
     /**
-     * Drop the planner turn in flight together with the plan it was answering:
+     * Drop the planner turn in flight together with the plan it was answering,
+     * or the session another host took from under it:
      * it is stopped, whatever it settles is discarded, and the conversation is
      * free at once rather than when the abandoned turn finishes unwinding.
      */
@@ -6184,21 +6350,6 @@ declare function resolveTaskRef<T extends RefTask<T>>(tasks: readonly T[], ref:
  */
 declare function resolveUserTaskRef<T extends RefTask<T>>(tasks: readonly T[], ref: string | number): T | undefined;
 
-interface SessionMeta {
-    id: string;
-    goal: string;
-    runners: RunnerId[];
-    taskCount: number;
-    status: PlanStatus;
-    createdAt: string;
-    updatedAt: string;
-}
-interface SessionData {
-    meta: SessionMeta;
-    /** The full plan state — including conversationHistory, prdMarkdown, and queuedMessages. */
-    plan: LegacyPlanState;
-}
-
 /** One repo that kept "Merge all" from touching anything, as part of one line. */
 declare function blockNotice({ repo, reason, files, expected, actual, rebasing }: IsolationMergeBlock): string;
 /** Every repo's reason, in the order "Merge all" named them, so a surface can list them or join them. */
@@ -6260,9 +6411,9 @@ interface IsolationPreviewNotice {
 declare function describeIsolationPreview(preview: IsolationPreview): IsolationPreviewNotice;
 
 /**
- * Pure, no-imports helper so a browser surface can format a conflict's files
- * without pulling `isolationRecord` — and its `path` import — into a webview
- * bundle. Kept out of `isolationRecord.ts` for exactly that reason.
+ * Pure helper so a browser surface can format a conflict's files without
+ * pulling `isolationRecord` — and its `path` import — into a webview bundle.
+ * Kept out of `isolationRecord.ts` for exactly that reason.
  */
 declare function capConflictFiles(files: string[], max?: number): string;
 
@@ -6333,6 +6484,12 @@ declare function repoResultLines(handoff: {
         landed: readonly unknown[];
     }[];
 }): string[];
+/**
+ * What a Merge all asks the user to confirm when a delegated task's check has
+ * not passed (ADR-0055 D9), the checks named as the plan names them. Every
+ * surface asks with these words, and the inbox's option carries them.
+ */
+declare function mergePastChecksConfirmation(checks: readonly string[]): string;
 
 /** What the user last picked for one planner backend. */
 interface PlannerModelChoice {
@@ -6500,6 +6657,13 @@ interface UserSettings {
      * no surface offers it.
      */
     taskRunnerConfig?: TaskRunnerConfig;
+    /**
+     * Run tasks in containers (ADR-0059 L5), as `containerSettings` reads it:
+     * absent means local worktrees. Kept as written, since one it cannot use must
+     * refuse a task, not fall back to the host. Set in the file only: no surface
+     * offers it.
+     */
+    containers?: unknown;
 }
 /**
  * The model allowlist, remembered planner models and enabled runners are shared
@@ -6700,7 +6864,9 @@ type DaemonErrorCode = 'session_not_found' | 'task_not_found' | 'no_plan' | 'alr
 /** The selected planner cannot plan yet (no key, no base URL, no model); `plannerNotReady` says which. */
  | 'planner_not_ready'
 /** The request asked for something the plan, task or conversation does not allow. */
- | 'refused' | 'checkpoint_not_waiting' | 'approval_not_outstanding'
+ | 'refused' | 'checkpoint_not_waiting'
+/** Merge all would merge work no check has passed; the message names the checks, and a surface asks before sending `pastChecks` (ADR-0055 D9). */
+ | 'merge_past_check' | 'approval_not_outstanding'
 /** Another live Ordewell host runs this session (ADR-0049); `sessionHeld` names it. */
  | 'session_held';
 /** The body of every non-2xx answer a route gives. */
@@ -7862,6 +8028,48 @@ declare function confirmedOverride(command: ExecutionCommand, seen?: TaskStatus)
 /** Change versus ops can still be flipped (ADR-0020): an AI task that has not started. */
 declare function opsEditable(task: ActionSubject): boolean;
 
+/**
+ * What a delegated task's row says (ADR-0055 D16, D20), in sentence case, each
+ * part null where there is nothing to say. Surfaces pick the glyphs and the
+ * layout, and derive none of the facts.
+ */
+interface TaskRowDelegated {
+    goal: string | null;
+    /** "1.3M of 2M tokens left". */
+    tokens: string | null;
+    /** "2 of 4 done, 1 running". */
+    counts: string | null;
+    /** That a Stop is still winding the subtree down. */
+    stopping: string | null;
+}
+declare const STOPPING_LABEL = "Stopping: its child plan is still winding down.";
+declare function delegatedRowView(task: {
+    type: string;
+    goal?: string;
+    delegation?: DelegatedRow;
+    handoff?: HandoffDigest;
+}): TaskRowDelegated | null;
+/** One finding of a delegated task's report, as a surface draws it. */
+interface SubtreeItemView {
+    /** The task and finding that name it, as a reader says them; null for a subplanner's own, which names no task. */
+    reference: string | null;
+    /** "F1 · Major · title". */
+    heading: string;
+    detail?: string;
+}
+/** What a delegated task's report adds to a handoff (ADR-0057 R2), worded once for every surface. */
+interface SubtreeView {
+    /** "3 done, 1 failed · 3 commits · 1.2M tokens · 1 major, 2 minor findings below". */
+    summary: string;
+    /** Changed outside its declared scope, or null (ADR-0056 M7). */
+    outsideScope: string | null;
+    /** What the parent must decide. */
+    open: SubtreeItemView[];
+    /** What the subplanner passed up. */
+    promoted: SubtreeItemView[];
+}
+declare function subtreeView(subtree: SubtreeReport): SubtreeView;
+
 /**
  * Where a loop's check stands, for the words a surface puts on its row
  * (ADR-0045): derived from the check's status, verdict and round, as a block
@@ -7954,6 +8162,9 @@ interface TaskRowSubject {
     loopStranded?: boolean;
     /** The latest attempt's handoff as the plan keeps it (ADR-0047); a row shows it without opening the task. */
     handoff?: HandoffDigest;
+    /** A delegated task's goal, and its row's live facts (ADR-0055 D20). */
+    goal?: string;
+    delegation?: DelegatedRow;
 }
 interface TaskRowIsolation {
     state: TaskIsolationState;
@@ -8015,7 +8226,7 @@ interface TaskRowContext {
  * or a script task (ADR-0035): an ops task by nature, drawn with its body and
  * with no prompt, runner or model to edit.
  */
-type TaskRowKind = 'ai' | 'user' | 'ops' | 'script';
+type TaskRowKind = 'ai' | 'user' | 'ops' | 'script' | 'delegated';
 /** The task's whole spend (see `taskUsageSummary`); `attempt` is the latest one, 0 before any reported. */
 interface TaskRowUsage extends Pick<TaskUsageSummary, 'totals' | 'contextFill'> {
     attempt: number;
@@ -8057,6 +8268,8 @@ type TaskRowLoop = {
     round: number | null;
 };
 interface TaskRowView {
+    /** A delegated task's goal, budget left, child counts and Stop (ADR-0055 D20); null on any other task. */
+    delegated: TaskRowDelegated | null;
     usage: TaskRowUsage | null;
     /** "2", or "2.1" for a subtask. */
     orderLabel: string;
@@ -8172,6 +8385,7 @@ declare function loopRowParts(loop: TaskRowLoop): string[];
  */
 interface TaskLogHeaderTask {
     status: string;
+    type?: string;
     awaitingReason?: AwaitingReason;
     skipReason?: string;
     resumeAt?: string | null;
@@ -8218,7 +8432,7 @@ interface TaskLogHeaderView {
 /** The commands the attempt on screen loaded (#66): the last `runner_loaded` block of its log. */
 declare function taskLogCommands(view: Pick<TaskLogView, 'blocks'>): readonly RunnerCommand[];
 /** Whether an opened task's composer continues it rather than messaging its turn (ADR-0018, K1). */
-declare function logContinues(task: Pick<TaskLogHeaderTask, 'status' | 'awaitingReason' | 'continuable'>): boolean;
+declare function logContinues(task: Pick<TaskLogHeaderTask, 'type' | 'status' | 'awaitingReason' | 'continuable'>): boolean;
 /** Whether the composer resumes it now, once the user says the limit has reset; a subset of `logContinues`. */
 declare function logResumes(task: Pick<TaskLogHeaderTask, 'status' | 'awaitingReason' | 'continuable'>): boolean;
 /**
@@ -8314,18 +8528,12 @@ declare const PLANNED_WITH_LABEL = "Planned-with line in commits Ordewell writes
 declare const trailerSummary: (run: GlobalRunSettings) => string;
 declare const autorunSummary: (run: GlobalRunSettings) => string;
 declare const delegationSummary: (run: GlobalRunSettings) => string;
-/**
- * Whether any surface offers the delegation setting. Off until a delegated task
- * exists (ADR-0055 D21): until then a control for it promises something that
- * does nothing and warns about tokens that cannot be spent. The setting, its
- * validation and its stored value stay in core and stay inert; the delegated-task
- * slice turns this on, and only here.
- */
-declare const DELEGATION_OFFERED = false;
+/** Whether any surface offers the delegation setting, and whether a planner may write a delegated task. */
+declare const DELEGATION_OFFERED: boolean;
 declare const ACT_RISK = "Tasks it adds run too, ops tasks included, which can act on real systems unattended.";
 declare const AUTORUN_RISK = "Plans start without review, ops tasks included, which can act on real systems unattended. In Full nobody is asked at all: the planner may start anything, script tasks included, from a plan no person read.";
-/** What turning delegation on accepts below the root, as Act and autorun accept it at the root (ADR-0056 M9). */
-declare const DELEGATION_RISK = "A subplanner approves and runs its own plan, and no person reads it. Its change tasks keep the network they have in a flat run, so an instruction injected into something a subplanner read can become a plan nobody read, and run with that network.";
+/** What turning delegation on accepts below the root, as Act and autorun accept it at the root (ADR-0056 M9). A container is not named as a remedy: only its own setting runs one, a child's tasks included (ADR-0059). */
+declare const DELEGATION_RISK = "A subplanner approves and runs its own plan, and no person reads it. Its change tasks keep the network they have in a flat run, so an instruction injected into something a subplanner read can become a plan nobody read, and run with that network. Delegation starts no container of its own: containers are opt-in, and only that setting runs a child's tasks in one.";
 /** `on`/`off` as a switch's value; null for anything else. */
 declare function parseSwitch(arg: string): boolean | null;
 /** A delegation setting as typed: `off`, which is 0, or the tree's budget in tokens; null for anything else. */
@@ -8333,4 +8541,4 @@ declare function parseDelegation(arg: string): number | 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 DaemonErrorCode as $, ACT_RISK as A, type BlockingSubject as B, CHAT_COMMANDS as C, type CliAgentAiServiceDeps as D, type CommandBlock as E, type CommandDescriptor as F, type CommandOutcome as G, type CommandPayload as H, type CommandStatus as I, type CommandsResponse as J, type CompactionBlock as K, type CompactionStatus as L, type Consent as M, type ContextCondenseRequest as N, ConversationBusyError as O, type ConversationCompactResponse as P, type ConversationCompaction as Q, ConversationEditError as R, type ConversationForkResponse as S, type ConversationInput as T, type ConversationRequest as U, type ConversationRewindResponse as V, type ConversationTurn as W, type ConversationView as X, DEFAULT_WEB_READ_BUDGET as Y, DELEGATION_OFFERED as Z, DELEGATION_RISK as _, AUTORUN_RISK as a, type MergeGateEntry as a$, type DecideOptions as a0, type DiffRow as a1, type DiffRowKind as a2, type DiffStat as a3, type DisplayBlock as a4, EMPTY_CONVERSATION as a5, EMPTY_HOLD as a6, EMPTY_RUN as a7, EMPTY_TASK_LOG as a8, EMPTY_TASK_LOG_FOLLOW as a9, IDLE_ACTIVITY as aA, type INotification as aB, type IWebFetcher as aC, type IsolationDiffResponse as aD, type IsolationMergeResponse as aE, type IsolationPreviewNotice as aF, type IsolationPreviewResponse as aG, IsolationRunController as aH, LEASE_HEARTBEAT_MS as aI, LEASE_STALE_MS as aJ, LeaseHost as aK, type LeaseHostKind as aL, type LeaseHostOptions as aM, type LiveOutputLookup as aN, type LiveTail as aO, type LiveTailOptions as aP, type LocalEntry as aQ, type LoopCheckFacts as aR, type LoopCheckState as aS, type LoopGuard as aT, type Mandate as aU, type MandateExclusions as aV, type MandateLimits as aW, type MandateRefusal as aX, type MandateRequest as aY, type MappedTool as aZ, type MarkdownToken as a_, type EffectRules as aa, type ErrorBody as ab, type Escalation as ac, type EscalationInput as ad, type EscalationKind as ae, type EscalationOption as af, type EscalationOptionId as ag, type EscalationRun as ah, type EscalationsResponse as ai, type ExecuteCommandResponse as aj, type ExecuteResponse as ak, type ExecutionCommand as al, ExecutionCommands as am, type ExecutionHost as an, type ExecutionSummary as ao, FLOOR_GRANTS as ap, GRANTS as aq, type GatedConversation as ar, type GeneratePlanResponse as as, type GlobalRunSettings as at, type Grant as au, HEADLESS_CLI_COMMANDS as av, type HandoffBlock as aw, type HandoffForkRepo as ax, type HandoffPeekSubject as ay, type IAiService as az, type AccountLimitBucket as b, type RootSettings as b$, type MergeGateResponse as b0, type MergeWordingHandoff as b1, type MessageBlock as b2, type MessageRole as b3, type ModelsResponse as b4, NOT_STARTED as b5, NO_TURN as b6, type Narrowed as b7, type NewTaskFields as b8, type NodeAuthority as b9, type PlannerModelChoice as bA, PlannerModelMemory as bB, type PlannerModelRecall as bC, type PlannerModelStore as bD, type PlannerModes as bE, type PlannerNotReady as bF, PlannerNotReadyError as bG, type PlannerReadinessConfig as bH, type PlannerSubmission as bI, PlannerTurnDiscardedError as bJ, PlannerTurnStoppedError as bK, PlannerUsageLimitError as bL, type PrdResponse as bM, type PromptHold as bN, REPORT_PREVIEW_LINES as bO, RUN_SETTINGS_DEFAULTS as bP, type ReadRunnerAuthOptions as bQ, type RefTask as bR, ResearchTasks as bS, type ResolveAll as bT, type ResolveConflictResponse as bU, type RevertPreviewTask as bV, type RevertRefusal as bW, type RevertRefusalReason as bX, type RevertScope as bY, type RewindTarget as bZ, type RewindTargetsResponse as b_, type NotificationAction as ba, OUTPUT_LINES_DEFAULT as bb, OUTPUT_LINES_MAX as bc, type OkResponse as bd, type OpRef as be, type OpRefusal as bf, type OrchestratorObserver as bg, type OutputPreview as bh, type OverrideDirection as bi, PLANNED_WITH_LABEL as bj, type PendingApproval as bk, PendingApprovals as bl, type PendingApprovalsOptions as bm, type PlanBlock as bn, type PlanBlocks as bo, type PlanIntake as bp, type PlanMarkerStatus as bq, type PlanResponse as br, type PlanSnapshot as bs, PlanStore as bt, type PlannerCommandSyntax as bu, type PlannerContextDeps as bv, type PlannerContextStatus as bw, PlannerConversation as bx, type PlannerConversationHost as by, type PlannerModelCandidate as bz, type AccountLimitSnapshot as c, type TaskLogBatch as c$, type RunActivity as c0, type RunInput as c1, type RunMergeView as c2, RunSettingsError as c3, type RunSnapshotFrame as c4, type RunTask as c5, type RunTaskStatus as c6, type RunView as c7, type RunnerAuth as c8, type RunnerAuthExec as c9, type SessionResponse as cA, type SettingsResponse as cB, SettingsService as cC, type SettingsUpdateResponse as cD, type SkillInvocation as cE, type SkillLoadBlock as cF, type SkillToken as cG, type StartAdmission as cH, type StopResponse as cI, type StreamStamp as cJ, type SubagentBlock as cK, type SubagentChild as cL, type SubagentStatus as cM, type SurfacePlan as cN, type SurfacePlanState as cO, type SurfaceTask as cP, TASK_QUERY_ANSWER_MAX_CHARS as cQ, TASK_QUERY_ANSWER_OR_OPS as cR, TASK_QUERY_FIELDS as cS, TASK_QUERY_PROTOCOL as cT, TASK_QUERY_REMINDER as cU, TERMINAL_UI_COMMANDS as cV, type TakenPrompt as cW, type TaskAction as cX, type TaskActivity as cY, type TaskAttemptSnapshot as cZ, type TaskLogAttemptsResponse as c_, type RunnerAuthExecOptions as ca, type RunnerAuthExecResult as cb, type RunnerCatalog as cc, type RunnerLoadedBlock as cd, type RunnersResponse as ce, SHAPE_LIMITS as cf, STALLED_LABEL as cg, STOPPED_BEFORE_START as ch, SUPERVISOR_LEVEL_LABEL as ci, type SerializedConversationMessage as cj, type SerializedPendingTurn as ck, type SerializedPlan as cl, type SerializedTask as cm, type SerializedTaskStatus as cn, type ServerInfoResponse as co, type SessionBroadcaster as cp, type SessionData as cq, type SessionFrame as cr, type SessionHeld as cs, SessionHeldError as ct, type SessionLease as cu, type SessionLeaseRecord as cv, type SessionListResponse as cw, type SessionMessage as cx, type SessionMeta as cy, type SessionNotice as cz, type AccountLimitStatus as d, approvalStatusText as d$, type TaskLogEvent as d0, type TaskLogFollow as d1, type TaskLogFollowInput as d2, type TaskLogHeaderKind as d3, type TaskLogHeaderTask as d4, type TaskLogHeaderUsage as d5, type TaskLogHeaderView as d6, type TaskLogResponse as d7, type TaskLogView as d8, type TaskMessageResponse as d9, type ToolBlock as dA, type ToolHeadline as dB, type ToolStatus as dC, type TreeTask as dD, TurnBudgets as dE, type TurnGate as dF, type UsageBlock as dG, type UserSettings as dH, WAITS_FOR_APPROVAL_LABEL as dI, type WakeUpItem as dJ, type WebRead as dK, type WebReadDecision as dL, type WebReadOptions as dM, WebReadPolicy as dN, type Worded as dO, type WorkspacesResponse as dP, abbreviateHome as dQ, accountLimitPercentText as dR, accountLimitWindowLabel as dS, accountLimitsOf as dT, accountLimitsText as dU, accountLimitsTitle as dV, activityLabel as dW, aheadOfDraft as dX, applyTaskOps as dY, approvalKindText as dZ, approvalLabel as d_, type TaskOp as da, TaskOrchestrator as db, type TaskOrchestratorDeps as dc, type TaskOrchestratorOptions as dd, type TaskOutputSource as de, type TaskPlacement as df, type TaskQuery as dg, type TaskQueryCatalog as dh, type TaskQueryField as di, type TaskRef as dj, type TaskRevertPreview as dk, type TaskRevertPreviewResponse as dl, type TaskRowAction as dm, type TaskRowContext as dn, type TaskRowHandoff as dp, type TaskRowIsolation as dq, type TaskRowKind as dr, type TaskRowLoop as ds, type TaskRowPlacement as dt, type TaskRowSubject as du, type TaskRowUsage as dv, type TaskRowView as dw, type TaskRunFacts as dx, type TaskStatusKind as dy, type ThinkingDisplayBlock as dz, type AccountLimitWindow as e, logContinues as e$, assignedRunnerOf as e0, assignmentIssue as e1, assignmentIssueText as e2, attachingLabel as e3, automergeSummary as e4, autorunSummary as e5, awaitingLabel as e6, blockNotice as e7, blockNotices as e8, blockedByLabel as e9, digestTaskLog as eA, drainNext as eB, editableWhileRunning as eC, effectRuleFor as eD, elapsedSince as eE, escalations as eF, executionSummary as eG, followTaskLog as eH, followTurn as eI, formatElapsed as eJ, fromTranscript as eK, getSettingsPath as eL, handoffBaseLine as eM, handoffBranchName as eN, handoffFindingsText as eO, handoffPeekParts as eP, hasAccountLimits as eQ, hasHiddenDetail as eR, hasLongReport as eS, heldMandate as eT, holdLabel as eU, holdPrompt as eV, isFileEditTool as eW, isRepoGroup as eX, isTaskRunning as eY, lastServedModel as eZ, loadedSkillTokens as e_, blockingFailures as ea, canMergeTasks as eb, canSetDependencies as ec, canSplitTask as ed, capConflictFiles as ee, cardEditNeedsUnstarted as ef, cardEditable as eg, checkoutRule as eh, classifyOutcome as ei, closeTurn as ej, coalesceTaskLog as ek, compactionText as el, confirmedOverride as em, createAiService as en, delegationSummary as eo, dependencyCandidates as ep, dependentsNotice as eq, dependentsOf as er, describeHeld as es, describeHolder as et, describeIsolationPreview as eu, describeMergeResult as ev, describePlannerNotReady as ew, diffRows as ex, diffStat as ey, diffSummary as ez, type AccountLimitsFrame as f, resumeTime as f$, logResumes as f0, loopBodyLabel as f1, loopBodyRound as f2, loopCheckLabel as f3, loopCheckState as f4, loopLeaveNotice as f5, loopRowParts as f6, mandateRefusalText as f7, manualOverrideConfirmation as f8, manualOverrideStopFirst as f9, plannerNotReady as fA, plannerNotReadyFor as fB, plannerTranscript as fC, processLeaseHost as fD, ranSealed as fE, readRunnerAuth as fF, receiptLabel as fG, reconcileApprovals as fH, recordRunnerAuth as fI, recordedRunnerAuth as fJ, reduceConversation as fK, reduceRun as fL, reduceTaskLog as fM, renderTaskQueryAnswer as fN, repairWaitLabel as fO, repairedLanded as fP, repairedNotice as fQ, repeatingChecks as fR, replayTaskLog as fS, repoBaseLine as fT, repoResultLines as fU, reposWithWork as fV, resetRunnerAuth as fW, resolveSkillInvocation as fX, resolveTaskRef as fY, resolveUserTaskRef as fZ, resumeLabel as f_, mapAgentTool as fa, markAction as fb, markdownHtml as fc, markdownTokens as fd, mergeOutcome as fe, mergeTarget as ff, namedRepos as fg, narrow as fh, newTaskFields as fi, noExecutorRefusal as fj, normalizeAgentArgs as fk, opRefusalText as fl, opsEditable as fm, outputLines as fn, outputPreview as fo, overrideNeedsConfirmation as fp, parseCount as fq, parseDelegation as fr, parseEffectAllowlist as fs, parseSwitch as ft, parseTaskOpsJson as fu, parseTaskQueryJson as fv, pastGateConfirmation as fw, planBlocks as fx, planMarkerParts as fy, plannerMessage as fz, type AccountLimitsMessage as g, revertEffect as g0, revertListLine as g1, revertTaskRef as g2, rootAuthority as g3, rootMandate as g4, runHoldsEditors as g5, runSettingsOf as g6, runnerToolSubject as g7, scriptExitText as g8, scriptRunText as g9, taskStartedNotice as gA, taskStatusKind as gB, textHasTaskOps as gC, textHasTaskQuery as gD, titledRefs as gE, titledTaskRef as gF, titledTaskRefOf as gG, toTaskLogEvent as gH, toolHeadline as gI, trailerSummary as gJ, trimToolOutput as gK, truncateCheckpointSummary as gL, unsendAll as gM, unsendLatest as gN, wakeUpItems as gO, walkPlan as gP, withoutSealedMark as gQ, workspaceEnvOf as gR, secondsText as ga, serializePlan as gb, serializeTask as gc, serializeTaskStatus as gd, skillTokens as ge, skippedLabel as gf, stopTurn as gg, subtreeIds as gh, summarizeToolCall as gi, supervisorSummary as gj, surfacePlan as gk, surfacePlanState as gl, takeAt as gm, taskActionCommand as gn, taskActivity as go, taskChatAvailable as gp, taskLogCommands as gq, taskLogForSurface as gr, taskLogHeaderView as gs, taskOrderLabel as gt, taskPlacement as gu, taskQuerySignature as gv, taskRef as gw, taskRefOf as gx, taskRowActions as gy, taskRowView as gz, type AdoptSessionResponse as h, type AnswerEscalationRequest as i, type ApplyTaskOpsResult as j, type ApprovalAnswerResponse as k, type ApprovalBlock as l, type ApprovalRequestMessage as m, type ApprovalStatus as n, type ApprovalsResponse as o, type ApproveReviewResponse as p, type AskOptions as q, type AssignmentCatalog as r, type AssignmentIssue as s, type AssignmentScope as t, type AssignmentWriter as u, type AutoMergeTrigger as v, CHECKPOINT_TRUNCATE_LENGTH as w, type CancelPlanningResponse as x, type CancelResumeResponse as y, CliAgentAiService as z };
+export { DELEGATION_RISK as $, ACT_RISK as A, type BlockingSubject as B, CHAT_COMMANDS as C, CliAgentAiService as D, type CliAgentAiServiceDeps as E, type CommandBlock as F, type CommandDescriptor as G, type CommandOutcome as H, type CommandPayload as I, type CommandStatus as J, type CommandsResponse as K, type CompactionBlock as L, type CompactionStatus as M, type Consent as N, type ContextCondenseRequest as O, ConversationBusyError as P, type ConversationCompactResponse as Q, type ConversationCompaction as R, ConversationEditError as S, type ConversationForkResponse as T, type ConversationInput as U, type ConversationRequest as V, type ConversationRewindResponse as W, type ConversationTurn as X, type ConversationView as Y, DEFAULT_WEB_READ_BUDGET as Z, DELEGATION_OFFERED as _, AUTORUN_RISK as a, type NodeBudget as a$, type DaemonErrorCode as a0, type DecideOptions as a1, type DiffRow as a2, type DiffRowKind as a3, type DiffStat as a4, type DisplayBlock as a5, EMPTY_CONVERSATION as a6, EMPTY_HOLD as a7, EMPTY_RUN as a8, EMPTY_TASK_LOG as a9, type IsolationMergeResponse as aA, type IsolationPreviewNotice as aB, type IsolationPreviewResponse as aC, LEASE_HEARTBEAT_MS as aD, LEASE_STALE_MS as aE, LeaseHost as aF, type LeaseHostKind as aG, type LeaseHostOptions as aH, type LiveOutputLookup as aI, type LiveTail as aJ, type LiveTailOptions as aK, type LocalEntry as aL, type LoopCheckFacts as aM, type LoopCheckState as aN, type LoopGuard as aO, type MappedTool as aP, type MarkdownToken as aQ, type MergeGateEntry as aR, type MergeGateResponse as aS, type MergeWordingHandoff as aT, type MessageBlock as aU, type MessageRole as aV, type ModelsResponse as aW, NOT_STARTED as aX, NO_TURN as aY, type NewTaskFields as aZ, NodeBoard as a_, EMPTY_TASK_LOG_FOLLOW as aa, type ErrorBody as ab, type Escalation as ac, type EscalationInput as ad, type EscalationKind as ae, type EscalationOption as af, type EscalationOptionId as ag, type EscalationRun as ah, type EscalationsResponse as ai, type ExecuteCommandResponse as aj, type ExecuteResponse as ak, type ExecutionCommand as al, ExecutionCommands as am, type ExecutionHost as an, type ExecutionSummary as ao, type GatedConversation as ap, type GeneratePlanResponse as aq, type GlobalRunSettings as ar, HEADLESS_CLI_COMMANDS as as, type HandoffBlock as at, type HandoffForkRepo as au, type HandoffPeekSubject as av, type IAiService as aw, IDLE_ACTIVITY as ax, type IWebFetcher as ay, type IsolationDiffResponse as az, type AccountLimitBucket as b, type RunnerCatalog as b$, OUTPUT_LINES_DEFAULT as b0, OUTPUT_LINES_MAX as b1, type OkResponse as b2, type OpRef as b3, type OpRefusal as b4, type OrchestratorObserver as b5, type OutputPreview as b6, type OverrideDirection as b7, PLANNED_WITH_LABEL as b8, type PendingApproval as b9, type PrdResponse as bA, type PromptHold as bB, REPORT_PREVIEW_LINES as bC, RUN_SETTINGS_DEFAULTS as bD, type ReadRunnerAuthOptions as bE, type RefTask as bF, ResearchTasks as bG, type ResolveAll as bH, type ResolveConflictResponse as bI, type RevertPreviewTask as bJ, type RevertRefusal as bK, type RevertRefusalReason as bL, type RevertScope as bM, type RewindTarget as bN, type RewindTargetsResponse as bO, type RunActivity as bP, type RunInput as bQ, type RunMergeView as bR, RunSettingsError as bS, type RunSnapshotFrame as bT, type RunTask as bU, type RunTaskStatus as bV, type RunView as bW, type RunnerAuth as bX, type RunnerAuthExec as bY, type RunnerAuthExecOptions as bZ, type RunnerAuthExecResult as b_, PendingApprovals as ba, type PendingApprovalsOptions as bb, type PlanBlock as bc, type PlanBlocks as bd, type PlanIntake as be, type PlanMarkerStatus as bf, type PlanResponse as bg, type PlanSnapshot as bh, PlanStore as bi, type PlannerCommandSyntax as bj, type PlannerContextDeps as bk, type PlannerContextStatus as bl, PlannerConversation as bm, type PlannerConversationHost as bn, type PlannerModelCandidate as bo, type PlannerModelChoice as bp, PlannerModelMemory as bq, type PlannerModelRecall as br, type PlannerModelStore as bs, type PlannerNotReady as bt, PlannerNotReadyError as bu, type PlannerReadinessConfig as bv, type PlannerSubmission as bw, PlannerTurnDiscardedError as bx, PlannerTurnStoppedError as by, PlannerUsageLimitError as bz, type AccountLimitSnapshot as c, type TaskMessageResponse as c$, type RunnerLoadedBlock as c0, type RunnersResponse as c1, STALLED_LABEL as c2, STOPPED_BEFORE_START as c3, STOPPING_LABEL as c4, SUPERVISOR_LEVEL_LABEL as c5, type SerializedConversationMessage as c6, type SerializedPendingTurn as c7, type SerializedPlan as c8, type SerializedTask as c9, Subtree as cA, type SubtreeItemView as cB, type SubtreeView as cC, type SurfacePlan as cD, type SurfacePlanState as cE, type SurfaceTask as cF, TASK_QUERY_ANSWER_MAX_CHARS as cG, TASK_QUERY_ANSWER_OR_OPS as cH, TASK_QUERY_FIELDS as cI, TASK_QUERY_PROTOCOL as cJ, TASK_QUERY_REMINDER as cK, TERMINAL_UI_COMMANDS as cL, type TakenPrompt as cM, type TaskAction as cN, type TaskActivity as cO, type TaskAttemptSnapshot as cP, type TaskLogAttemptsResponse as cQ, type TaskLogBatch as cR, type TaskLogEvent as cS, type TaskLogFollow as cT, type TaskLogFollowInput as cU, type TaskLogHeaderKind as cV, type TaskLogHeaderTask as cW, type TaskLogHeaderUsage as cX, type TaskLogHeaderView as cY, type TaskLogResponse as cZ, type TaskLogView as c_, type SerializedTaskStatus as ca, type ServerInfoResponse as cb, type SessionBroadcaster as cc, type SessionFrame as cd, type SessionHeld as ce, SessionHeldError as cf, type SessionLease as cg, type SessionLeaseRecord as ch, type SessionListResponse as ci, type SessionMessage as cj, type SessionNotice as ck, type SessionResponse as cl, type SettingsResponse as cm, SettingsService as cn, type SettingsUpdateResponse as co, type SkillInvocation as cp, type SkillLoadBlock as cq, type SkillToken as cr, SlotPool as cs, type StartAdmission as ct, type StopResponse as cu, type StreamStamp as cv, type SubagentBlock as cw, type SubagentChild as cx, type SubagentStatus as cy, type SubplannerBrief as cz, type AccountLimitStatus as d, blockNotice as d$, type TaskOp as d0, TaskOrchestrator as d1, type TaskOrchestratorDeps as d2, type TaskOrchestratorOptions as d3, type TaskOutputSource as d4, type TaskPlacement as d5, type TaskQuery as d6, type TaskQueryCatalog as d7, type TaskQueryField as d8, type TaskRef as d9, WAITS_FOR_APPROVAL_LABEL as dA, type WakeUpItem as dB, type WebRead as dC, type WebReadDecision as dD, type WebReadOptions as dE, WebReadPolicy as dF, type Worded as dG, type WorkspacesResponse as dH, abbreviateHome as dI, accountLimitPercentText as dJ, accountLimitWindowLabel as dK, accountLimitsOf as dL, accountLimitsText as dM, accountLimitsTitle as dN, activityLabel as dO, aheadOfDraft as dP, applyTaskOps as dQ, approvalKindText as dR, approvalLabel as dS, approvalStatusText as dT, assignedRunnerOf as dU, assignmentIssue as dV, assignmentIssueText as dW, attachingLabel as dX, automergeSummary as dY, autorunSummary as dZ, awaitingLabel as d_, type TaskRevertPreview as da, type TaskRevertPreviewResponse as db, type TaskRowAction as dc, type TaskRowContext as dd, type TaskRowDelegated as de, type TaskRowHandoff as df, type TaskRowIsolation as dg, type TaskRowKind as dh, type TaskRowLoop as di, type TaskRowPlacement as dj, type TaskRowSubject as dk, type TaskRowUsage as dl, type TaskRowView as dm, type TaskRunFacts as dn, type TaskStatusKind as dp, type ThinkingDisplayBlock as dq, type ToolBlock as dr, type ToolHeadline as ds, type ToolStatus as dt, TreeLedger as du, type TreeTask as dv, TurnBudgets as dw, type TurnGate as dx, type UsageBlock as dy, type UserSettings as dz, type AccountLimitWindow as e, manualOverrideStopFirst as e$, blockNotices as e0, blockedByLabel as e1, blockingFailures as e2, canMergeTasks as e3, canSetDependencies as e4, canSplitTask as e5, capConflictFiles as e6, cardEditNeedsUnstarted as e7, cardEditable as e8, checkoutRule as e9, followTurn as eA, formatElapsed as eB, fromTranscript as eC, getSettingsPath as eD, handoffBaseLine as eE, handoffBranchName as eF, handoffFindingsText as eG, handoffPeekParts as eH, hasAccountLimits as eI, hasHiddenDetail as eJ, hasLongReport as eK, holdLabel as eL, holdPrompt as eM, isFileEditTool as eN, isRepoGroup as eO, isTaskRunning as eP, lastServedModel as eQ, loadedSkillTokens as eR, logContinues as eS, logResumes as eT, loopBodyLabel as eU, loopBodyRound as eV, loopCheckLabel as eW, loopCheckState as eX, loopLeaveNotice as eY, loopRowParts as eZ, manualOverrideConfirmation as e_, classifyOutcome as ea, closeTurn as eb, coalesceTaskLog as ec, compactionText as ed, confirmedOverride as ee, createAiService as ef, delegatedRowView as eg, delegationSummary as eh, dependencyCandidates as ei, dependentsNotice as ej, dependentsOf as ek, describeHeld as el, describeHolder as em, describeIsolationPreview as en, describeMergeResult as eo, describePlannerNotReady as ep, diffRows as eq, diffStat as er, diffSummary as es, digestTaskLog as et, drainNext as eu, editableWhileRunning as ev, elapsedSince as ew, escalations as ex, executionSummary as ey, followTaskLog as ez, type AccountLimitsFrame as f, serializeTask as f$, mapAgentTool as f0, markAction as f1, markdownHtml as f2, markdownTokens as f3, mergeOutcome as f4, mergePastChecksConfirmation as f5, mergeTarget as f6, namedRepos as f7, newTaskFields as f8, noExecutorRefusal as f9, reduceRun as fA, reduceTaskLog as fB, renderTaskQueryAnswer as fC, repairWaitLabel as fD, repairedLanded as fE, repairedNotice as fF, repeatingChecks as fG, replayTaskLog as fH, repoBaseLine as fI, repoResultLines as fJ, reposWithWork as fK, resetRunnerAuth as fL, resolveSkillInvocation as fM, resolveTaskRef as fN, resolveUserTaskRef as fO, resumeLabel as fP, resumeTime as fQ, revertEffect as fR, revertListLine as fS, revertTaskRef as fT, runHoldsEditors as fU, runSettingsOf as fV, runnerToolSubject as fW, scriptExitText as fX, scriptRunText as fY, secondsText as fZ, serializePlan as f_, normalizeAgentArgs as fa, opRefusalText as fb, opsEditable as fc, outputLines as fd, outputPreview as fe, overrideNeedsConfirmation as ff, parseCount as fg, parseDelegation as fh, parseSwitch as fi, parseTaskOpsJson as fj, parseTaskQueryJson as fk, pastGateConfirmation as fl, planBlocks as fm, planMarkerParts as fn, plannerMessage as fo, plannerNotReady as fp, plannerNotReadyFor as fq, plannerTranscript as fr, processLeaseHost as fs, ranSealed as ft, readRunnerAuth as fu, receiptLabel as fv, reconcileApprovals as fw, recordRunnerAuth as fx, recordedRunnerAuth as fy, reduceConversation as fz, type AccountLimitsMessage as g, serializeTaskStatus as g0, skillTokens as g1, skippedLabel as g2, stopTurn as g3, subtreeIds as g4, subtreeView as g5, summarizeToolCall as g6, supervisorSummary as g7, surfacePlan as g8, surfacePlanState as g9, unsendAll as gA, unsendLatest as gB, wakeUpItems as gC, walkPlan as gD, withoutSealedMark as gE, workspaceEnvOf as gF, takeAt as ga, taskActionCommand as gb, taskActivity as gc, taskChatAvailable as gd, taskLogCommands as ge, taskLogForSurface as gf, taskLogHeaderView as gg, taskOrderLabel as gh, taskPlacement as gi, taskQuerySignature as gj, taskRef as gk, taskRefOf as gl, taskRowActions as gm, taskRowView as gn, taskStartedNotice as go, taskStatusKind as gp, textHasTaskOps as gq, textHasTaskQuery as gr, titledRefs as gs, titledTaskRef as gt, titledTaskRefOf as gu, toTaskLogEvent as gv, toolHeadline as gw, trailerSummary as gx, trimToolOutput as gy, truncateCheckpointSummary as gz, type AdoptSessionResponse as h, type AnswerEscalationRequest as i, type ApplyTaskOpsResult as j, type ApprovalAnswerResponse as k, type ApprovalBlock as l, type ApprovalRequestMessage as m, type ApprovalStatus as n, type ApprovalsResponse as o, type ApproveReviewResponse as p, type AskOptions as q, type AssignmentCatalog as r, type AssignmentIssue as s, type AssignmentScope as t, type AssignmentWriter as u, type AutoMergeTrigger as v, CHECKPOINT_TRUNCATE_LENGTH as w, type CancelPlanningResponse as x, type CancelResumeResponse as y, type Carved as z };