@ordewell/core 0.11.3 → 0.12.1

package/dist/{runSettingsText-DVOd7vKC.d.ts → runSettingsText-DFVpe6aU.d.mts}

@@ -1,357 +1,27 @@
-import { aP as StoredHandoff, aS as Task, az as RunnerId, b0 as TaskSnapshot, b as AwaitingReason, b6 as UsageRecord, aA as RunnerSessionCost, i as DiscoveredModel, aO as SkillsService, aJ as SkillInfo, aq as RepoGroupLayout, x as IWorktreeIsolation, X as IsolationRun, K as IsolationHandoff, a8 as PlanIsolation, Y as IsolationTaskRecord, aV as TaskIsolation, a0 as IsolationView, ah as PrepareIntent, al as PreviousWork, q as HandoffCommit, S as IsolationOutcome, ao as RepairEvidence, b4 as TreeSnapshot, aT as TaskDiffRead, aU as TaskDiffResult, R as IsolationMergeResult, b8 as Verdict, a1 as LegacyPlanState, aZ as TaskReportTo, a$ as TaskSkillSnapshot, a_ as TaskSkillNotice, aQ as SubagentOutcome, d as ConversationMessage, aL as SkillLoadNotice, a7 as PendingPlanTurn, r as HandoffDigest, a as AttemptUsage, aX as TaskLoop, ay as RunSettings, ab as PlanUsage, ap as ReplyRun, aE as SessionBilling, a4 as ModelUsage, b7 as UsageTotals, c as ContextFill, ac as PlannerCompaction, k as ExecutionRecord, av as ResearchStep, a9 as PlanState, b1 as TaskStatus, E as ExecutionActor, l as GuardTrip, aR as SupervisorLevel, j as ExecutionCommandName, G as GuardTarget, au as ResearchProgress, at as ResearchLogEntry, aK as SkillLoad, ae as PlannerContextPause, aa as PlanStatus, P as IsolationMergeBlock, N as IsolationLandedTask, T as IsolationPreview, ax as ResearchToolType, a2 as LoopSubject, aw as ResearchStepOutcome, ad as PlannerCompactionOutcome, ag as PlannerUsage, F as FindingSeverity, b2 as TaskType, a6 as PatchView, aW as TaskIsolationState, b3 as TaskUsageSummary } from './Task-BL4Idm9r.js';
-import { q as ApprovalRequest, r as ApprovalSource, N as IApproval, br as ToolOutcome, R as IRunnerSession, O as IConfig, bs 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, ar as QueuedTaskMessage, l as ApprovalKind, Q as IRunner, aO as RunnerRegistry, bm as TaskShellSite, bl as TaskShell, aW as ScriptBody, d as AgentProcessDeps, a as AgentAdapter, a9 as OrdewellMcpServer, P as IFileSystem, am as PlannerToolHandler, j as ApprovalAnswer, aJ as RunnerManifest, f as AiProvider, ag as PlannerBackendId, a8 as OrchestratorOption } from './IRunner-DOMtDTVt.js';
-import { R as RunnerModeInfo } from './ModeResolver-DyXeZ9ib.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.mjs';
+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-CcB8yELZ.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-CA2fUU9h.mjs';
 
-type NotificationAction = {
-    label: string;
-    value: string;
-};
-interface INotification {
-    info(msg: string): void;
-    warn(msg: string): void;
-    error(msg: string): void;
-    confirm(msg: string, options: string[]): Promise<string | undefined>;
-}
-
-/**
- * The 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
- * the cloud metadata credentials, so every outbound host is vetted here: IP
- * literals by range, names by every address DNS answers with.
- */
-type ResolveAll = (host: string) => Promise<string[]>;
-
-/**
- * The one decision every planner web read goes through, whichever runner
- * plans and whichever path carries the bytes (ADR-0027). A fetch names the
- * URL it reads; a search names its query and the provider that receives it.
- */
-type WebRead = {
-    kind: 'fetch';
-    url: string;
-}
-/** `provider` keys the grant; `providerLabel`, when given, names it to the person asked. */
- | {
-    kind: 'search';
-    query: string;
-    provider: string;
-    providerLabel?: string;
-    note?: string;
-};
-/** A refusal's `reason` is written for the planner: it says what to do next. */
-type WebReadDecision = {
-    allowed: true;
-} | {
-    allowed: false;
-    reason: string;
-};
-interface DecideOptions {
-    /**
-     * Research subagents run in the background where nothing can prompt
-     * (ADR-0008, T6). When false, a read that would ask is refused with the gap
-     * to report, rather than raising a prompt nobody can answer.
-     */
-    prompting?: boolean;
-    /**
-     * Where this read's decisions go, the first URL's and any redirect hop's,
-     * in place of the session's approval record. A read-only task's are its
-     * attempt's, never the planner's (ADR-0046), so its policy records nothing
-     * without one.
-     */
-    record?: DecisionRecord;
-}
-type DecisionRecord = (req: ApprovalRequest, granted: boolean, source: ApprovalSource) => void;
-interface WebReadPolicyOptions {
-    approval: IApproval;
-    /** The secrets Ordewell holds — provider keys, MCP tokens — read per request. */
-    secrets?: () => Iterable<string>;
-    /** Defaults to `process.env`; its credential-named values are secrets too. */
-    env?: () => Record<string, string | undefined>;
-    /** How many web reads one planner turn may make; read per request, so a settings change applies at once. */
-    budget?: () => number;
-    /** The planner turn in progress; a new one starts a new budget. */
-    turn?: () => string | undefined;
-    /** Override DNS resolution (every answer for a name) in tests. */
-    resolveHost?: ResolveAll;
-    /**
-     * The read-only task whose attempt reads (ADR-0046), by title, set by
-     * {@link WebReadPolicy.forTask}: named in approvals and refusals, and its
-     * budget is the policy's own for its whole life, whatever `turn` says.
-     */
-    task?: string;
-}
-declare const DEFAULT_WEB_READ_BUDGET = 40;
-declare class WebReadPolicy {
-    private readonly options;
-    private readonly reader;
-    private readonly approval;
-    private readonly resolveHost;
-    private readonly secrets;
-    private readonly env;
-    private readonly budget;
-    private readonly turn;
-    private spent;
-    constructor(opts: WebReadPolicyOptions);
-    /**
-     * The same policy for one read-only task attempt (ADR-0046): the same
-     * approval, allowlist, live secrets and budget setting, with a count of its
-     * own that no planner turn resets and no other attempt spends. One per
-     * attempt, so a retry or a continue starts a fresh count.
-     */
-    forTask(task: string): WebReadPolicy;
-    /**
-     * Every check that needs no network runs first, then the budget and the
-     * approval, and only then is a fetch's host resolved: a lookup is itself a
-     * request, so `<data>.attacker.example` would leave through DNS even for a
-     * read that is then excluded, over budget or declined.
-     */
-    decide(read: WebRead, opts?: DecideOptions): Promise<WebReadDecision>;
-    private subagentRefusal;
-    /**
-     * Whether a search through `provider` would run without asking anyone, for
-     * a runner whose own search raises no request and is set on or off when
-     * its session starts (ADR-0027). A zero budget disables it; no query is
-     * known yet, so secrets and individual reads cannot be checked or counted.
-     */
-    searchesUnasked(provider: string): boolean;
-    /** The last check, the one that leaves the machine: every DNS answer for the host must be public. */
-    private resolved;
-    private refuse;
-    /**
-     * A planner's decisions reach the session's record, the conversation's
-     * approval cards; a task attempt's go only where its read says, since they
-     * are not the planner's (ADR-0046).
-     */
-    private recordFor;
-    private vetFetch;
-    private vetSearch;
-    /** Reads the current planner turn, or the task attempt, may still make, for the reader to see. */
-    remaining(): number;
-    private spend;
-    private refund;
-    private carriesSecret;
-}
-
-/** What a caller that can go away hands a read: once `signal` aborts, nothing more leaves for it. */
-interface WebReadOptions {
-    signal?: AbortSignal;
-    /** Where the read's decisions go instead of the session's record; see `DecideOptions.record`. */
-    record?: DecisionRecord;
-}
-interface IWebFetcher {
-    /**
-     * The web-read policy's decision (ADR-0027), for a read this fetcher will
-     * carry or one a runner carries natively, such as Claude's `WebFetch`.
-     * `fetch` and `search` decide for themselves; never call both.
-     */
-    decide(read: WebRead): Promise<WebReadDecision>;
-    /** Whether a runner's own search through `provider` would run unasked; see `WebReadPolicy.searchesUnasked`. */
-    searchesUnasked?(provider: string): boolean;
-    fetch(url: string, opts?: WebReadOptions): Promise<ToolOutcome>;
-    /**
-     * Optional web search. A fetcher without it makes the `web_search` tool
-     * report itself unavailable rather than failing the turn — the same
-     * degradation `fetch` already uses when no fetcher is wired at all.
-     */
-    search?(query: string, opts?: WebReadOptions): Promise<ToolOutcome>;
-    /**
-     * A variant of this fetcher for a research subagent: same policy, cache,
-     * transport and budget, but a read that would ask a person is refused
-     * instead (ADR-0027, ADR-0008 T6). Absent means subagents get no web tools
-     * and the `fetch`/`web_search` tools report themselves unavailable.
-     */
-    forSubagent?(): IWebFetcher;
-    /**
-     * A variant for one read-only task attempt, `task` naming it (ADR-0046):
-     * a subagent's in never prompting, with a web-read budget of its own that
-     * no planner turn and no other attempt spends or resets. Absent, or
-     * undefined, means read-only tasks get no web reads, and their `fetch` and
-     * `web_search` report themselves unavailable.
-     */
-    forTask?(task: string): IWebFetcher | undefined;
-    /** Reads the current budget still allows, where this fetcher's policy counts them. */
-    remaining?(): number | undefined;
-}
-
-interface LiveTailOptions {
-    maxLines: number;
-    /** A previous {@link LiveTail.nextOffset}: only output after it is rendered. */
-    sinceOffset?: number;
-}
-interface LiveTail {
-    /** Plain text, escapes and control characters removed. */
-    text: string;
-    /** Total output received so far; pass it back as `sinceOffset` to read only what follows. */
-    nextOffset: number;
-    running: boolean;
-}
-/**
- * The one owner of a task attempt's output: what it printed while running
- * and what it answered once it ended.
- */
-interface TaskOutputSource {
-    /** Start capturing a session; replaces any earlier capture of the task. */
-    attach(taskId: string, session: IRunnerSession): void;
-    /** Stop capturing the task's session; what was captured stays readable. */
-    detach(taskId: string): void;
-    /** Drop every capture (a new plan reuses task ids). */
-    reset(): void;
-    /** The task's final answer: the summary its runner reported through `task_complete`, else what its last turn said. */
-    finalText(taskId: string): string;
-    /** The summary the runner reported through `task_complete` in its latest turn, if it made that call. */
-    report(taskId: string): string | undefined;
-    /** The handoff of that call, findings numbered (ADR-0047); undefined when the turn made none, or it handed nothing over. */
-    handoff(taskId: string): StoredHandoff | undefined;
-    /** Recent output of the task's latest capture, or null if it never had one. */
-    liveTail(taskId: string, opts: LiveTailOptions): LiveTail | null;
-}
-
-/**
- * The deep module owning all plan-shaped state. Holds `planTasks` (the ordered
- * tree the user edits), the flattened `allTasks` view and the `taskMap` index.
- * The orchestrator calls `markCompleted`/`markFailed`/`markInProgress`/`retry`
- * to update task status — it never mutates task state directly.
- *
- * Completion and failure are read from `task.status` and nothing else, so
- * `isCompleted`, `completedCount`, `isAllComplete` and the scheduler's
- * dependency checks cannot disagree. The store owns its task objects: `load`
- * copies what it is given, the getters hand out readonly views, and
- * `snapshot` is the copy a caller may keep or write to disk.
- *
- * `rebuild` is the internal seam that keeps the flat views in sync with the
- * tree.
- *
- * `planRunners` lives here because it's part of the plan's identity (the runner
- * set, carried on the plan). `assertAssignedRunners` is pure store logic.
- */
-declare class PlanStore {
-    private _planTasks;
-    private _allTasks;
-    private _taskMap;
-    /** Task id → the top-level task it hangs under, itself for a top-level task. */
-    private _rootMap;
-    private _planRunners;
-    private _onMutate;
-    private _onTree;
-    private _executionLog;
-    /** Hook called after every structural mutation (add/remove/update/resetForRun). */
-    set onMutate(cb: (() => void) | null);
-    /**
-     * Called with every task id, subtasks included, each time the tree is
-     * rebuilt — on every route a task enters or leaves the plan, loads and
-     * reconciled edits included, which `onMutate` does not hear.
-     */
-    set onTree(cb: ((ids: ReadonlySet<string>) => void) | null);
-    get planTasks(): ReadonlyArray<Readonly<Task>>;
-    get allTasks(): ReadonlyArray<Readonly<Task>>;
-    get planRunners(): RunnerId[];
-    get completedCount(): number;
-    get failedCount(): number;
-    isAllComplete(): boolean;
-    isAnyFailed(): boolean;
-    isCompleted(id: string): boolean;
-    isSkipped(id: string): boolean;
-    /** Nothing is left to do: every task completed or was skipped. */
-    isFinished(): boolean;
-    isFailed(id: string): boolean;
-    get(taskId: string): Readonly<Task> | undefined;
-    /**
-     * Whether a task runs as an ops task (ADR-0020): a top-level AI task marked
-     * so, or a script task, which is one by nature (ADR-0035). A subtask runs
-     * with the top-level task it hangs under.
-     */
-    isOps(taskId: string): boolean;
-    /** A copy of the task tree, detached from the store: later status changes do not reach it. */
-    snapshot(): Task[];
-    getExecutionLog(): ReadonlyArray<TaskSnapshot>;
-    appendToLog(snapshot: TaskSnapshot): void;
-    /**
-     * Drop a task's archived snapshot. Un-marking a completion has to erase the
-     * "finished" record too — dependent tasks are prompted from the log, so a
-     * left-behind snapshot would keep feeding them a result that no longer exists.
-     */
-    removeFromLog(taskId: string): void;
-    clearLog(): void;
-    private notifyMutate;
-    private countStatus;
-    /**
-     * `keepFailed` adopts failed tasks as failed: an edit reconciled into a run
-     * is not a retry, and the tasks it blocks wait for one (ADR-0034).
-     */
-    load(tasks: ReadonlyArray<Readonly<Task>>, runners: readonly RunnerId[], opts?: {
-        keepFailed?: boolean;
-    }): void;
-    add(partial: Partial<Task>): Task;
-    remove(taskId: string): void;
-    update(taskId: string, changes: Partial<Task>): Task | undefined;
-    /**
-     * Run preparation as one named op: flip every AI and script task to 'approved'. By
-     * default completed tasks keep their status so a reloaded half-finished plan
-     * resumes the remainder instead of re-running work that already succeeded,
-     * and skipped ones stay skipped: a new run is not a retry of them.
-     * `preserveCompleted: false` is for a freshly committed plan, where
-     * everything starts over. `keepScheduledResumes` leaves a task waiting on
-     * its runner's usage-limit reset waiting: an edit adopted between runs is
-     * not the user starting over.
-     */
-    resetForRun(opts?: {
-        preserveCompleted?: boolean;
-        keepScheduledResumes?: boolean;
-    }): void;
-    markCompleted(id: string): void;
-    markFailed(id: string): void;
-    markSkipped(id: string, reason?: string): void;
-    markInProgress(id: string): void;
-    /** Its first attempt is starting: from now on its chat exists, whatever becomes of the attempt. */
-    markAttempted(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;
-    /** 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;
-    /** 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;
+/** 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;
     /**
-     * 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.
+     * 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).
      */
-    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;
+    models?: AssignmentCatalog;
     /**
-     * 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.
+     * 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.
      */
-    admitRunner(runner: RunnerId): void;
-    resolveTaskRunner(task: Readonly<Task>): RunnerId;
-    private rebuild;
+    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;
 }
 
 /**
@@ -385,6 +55,10 @@ interface AssignmentCatalog {
     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;
     /**
@@ -556,377 +230,371 @@ declare function canSplitTask(tasks: readonly Task[], taskId: string): {
 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.
+ * 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
+ * the cloud metadata credentials, so every outbound host is vetted here: IP
+ * literals by range, names by every address DNS answers with.
+ */
+type ResolveAll = (host: string) => Promise<string[]>;
+
+/**
+ * The one decision every planner web read goes through, whichever runner
+ * plans and whichever path carries the bytes (ADR-0027). A fetch names the
+ * URL it reads; a search names its query and the provider that receives it.
  */
-/** Where a task's skill names are looked up: global first, then the workspace folders it reads. */
-interface SkillLookup extends Pick<SkillsService, 'findSkill' | 'searchedDirs'> {
+type WebRead = {
+    kind: 'fetch';
+    url: string;
+}
+/** `provider` keys the grant; `providerLabel`, when given, names it to the person asked. */
+ | {
+    kind: 'search';
+    query: string;
+    provider: string;
+    providerLabel?: string;
+    note?: string;
+};
+/** A refusal's `reason` is written for the planner: it says what to do next. */
+type WebReadDecision = {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: string;
+};
+interface DecideOptions {
+    /**
+     * Research subagents run in the background where nothing can prompt
+     * (ADR-0008, T6). When false, a read that would ask is refused with the gap
+     * to report, rather than raising a prompt nobody can answer.
+     */
+    prompting?: boolean;
     /**
-     * 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.
+     * Where this read's decisions go, the first URL's and any redirect hop's,
+     * in place of the session's approval record. A read-only task's are its
+     * attempt's, never the planner's (ADR-0046), so its policy records nothing
+     * without one.
      */
-    uncommitted?(skills: readonly SkillInfo[]): Promise<Map<string, string>>;
+    record?: DecisionRecord;
 }
-/**
- * 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;
+type DecisionRecord = (req: ApprovalRequest, granted: boolean, source: ApprovalSource) => void;
+interface WebReadPolicyOptions {
+    approval: IApproval;
+    /** The secrets Ordewell holds — provider keys, MCP tokens — read per request. */
+    secrets?: () => Iterable<string>;
+    /** Defaults to `process.env`; its credential-named values are secrets too. */
+    env?: () => Record<string, string | undefined>;
+    /** How many web reads one planner turn may make; read per request, so a settings change applies at once. */
+    budget?: () => number;
+    /** The planner turn in progress; a new one starts a new budget. */
+    turn?: () => string | undefined;
+    /** Override DNS resolution (every answer for a name) in tests. */
+    resolveHost?: ResolveAll;
+    /**
+     * The read-only task whose attempt reads (ADR-0046), by title, set by
+     * {@link WebReadPolicy.forTask}: named in approvals and refusals, and its
+     * budget is the policy's own for its whole life, whatever `turn` says.
+     */
+    task?: string;
+}
+declare const DEFAULT_WEB_READ_BUDGET = 40;
+declare class WebReadPolicy {
+    private readonly options;
+    private readonly reader;
+    private readonly approval;
+    private readonly resolveHost;
+    private readonly secrets;
+    private readonly env;
+    private readonly budget;
+    private readonly turn;
+    private spent;
+    constructor(opts: WebReadPolicyOptions);
+    /**
+     * The same policy for one read-only task attempt (ADR-0046): the same
+     * approval, allowlist, live secrets and budget setting, with a count of its
+     * own that no planner turn resets and no other attempt spends. One per
+     * attempt, so a retry or a continue starts a fresh count.
+     */
+    forTask(task: string): WebReadPolicy;
+    /**
+     * Every check that needs no network runs first, then the budget and the
+     * approval, and only then is a fetch's host resolved: a lookup is itself a
+     * request, so `<data>.attacker.example` would leave through DNS even for a
+     * read that is then excluded, over budget or declined.
+     */
+    decide(read: WebRead, opts?: DecideOptions): Promise<WebReadDecision>;
+    private subagentRefusal;
+    /**
+     * Whether a search through `provider` would run without asking anyone, for
+     * a runner whose own search raises no request and is set on or off when
+     * its session starts (ADR-0027). A zero budget disables it; no query is
+     * known yet, so secrets and individual reads cannot be checked or counted.
+     */
+    searchesUnasked(provider: string): boolean;
+    /** The last check, the one that leaves the machine: every DNS answer for the host must be public. */
+    private resolved;
+    private refuse;
+    /**
+     * A planner's decisions reach the session's record, the conversation's
+     * approval cards; a task attempt's go only where its read says, since they
+     * are not the planner's (ADR-0046).
+     */
+    private recordFor;
+    private vetFetch;
+    private vetSearch;
+    /** Reads the current planner turn, or the task attempt, may still make, for the reader to see. */
+    remaining(): number;
+    private spend;
+    private refund;
+    private carriesSecret;
 }
 
-/**
- * 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;
+/** What a caller that can go away hands a read: once `signal` aborts, nothing more leaves for it. */
+interface WebReadOptions {
+    signal?: AbortSignal;
+    /** Where the read's decisions go instead of the session's record; see `DecideOptions.record`. */
+    record?: DecisionRecord;
+}
+interface IWebFetcher {
+    /**
+     * The web-read policy's decision (ADR-0027), for a read this fetcher will
+     * carry or one a runner carries natively, such as Claude's `WebFetch`.
+     * `fetch` and `search` decide for themselves; never call both.
+     */
+    decide(read: WebRead): Promise<WebReadDecision>;
+    /** Whether a runner's own search through `provider` would run unasked; see `WebReadPolicy.searchesUnasked`. */
+    searchesUnasked?(provider: string): boolean;
+    fetch(url: string, opts?: WebReadOptions): Promise<ToolOutcome>;
+    /**
+     * Optional web search. A fetcher without it makes the `web_search` tool
+     * report itself unavailable rather than failing the turn — the same
+     * degradation `fetch` already uses when no fetcher is wired at all.
+     */
+    search?(query: string, opts?: WebReadOptions): Promise<ToolOutcome>;
     /**
-     * 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.
+     * A variant of this fetcher for a research subagent: same policy, cache,
+     * transport and budget, but a read that would ask a person is refused
+     * instead (ADR-0027, ADR-0008 T6). Absent means subagents get no web tools
+     * and the `fetch`/`web_search` tools report themselves unavailable.
+     */
+    forSubagent?(): IWebFetcher;
+    /**
+     * A variant for one read-only task attempt, `task` naming it (ADR-0046):
+     * a subagent's in never prompting, with a web-read budget of its own that
+     * no planner turn and no other attempt spends or resets. Absent, or
+     * undefined, means read-only tasks get no web reads, and their `fetch` and
+     * `web_search` report themselves unavailable.
      */
-    taskSkills?: SkillLookup;
+    forTask?(task: string): IWebFetcher | undefined;
+    /** Reads the current budget still allows, where this fetcher's policy counts them. */
+    remaining?(): number | undefined;
 }
 
-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;
+interface LiveTailOptions {
+    maxLines: number;
+    /** A previous {@link LiveTail.nextOffset}: only output after it is rendered. */
+    sinceOffset?: number;
+}
+interface LiveTail {
+    /** Plain text, escapes and control characters removed. */
+    text: string;
+    /** Total output received so far; pass it back as `sinceOffset` to read only what follows. */
+    nextOffset: number;
+    running: boolean;
+}
 /**
- * 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.
+ * The one owner of a task attempt's output: what it printed while running
+ * and what it answered once it ended.
  */
-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;
+interface TaskOutputSource {
+    /** Start capturing a session; replaces any earlier capture of the task. */
+    attach(taskId: string, session: IRunnerSession): void;
+    /** Stop capturing the task's session; what was captured stays readable. */
+    detach(taskId: string): void;
+    /** Drop every capture (a new plan reuses task ids). */
+    reset(): void;
+    /** The task's final answer: the summary its runner reported through `task_complete`, else what its last turn said. */
+    finalText(taskId: string): string;
+    /** The summary the runner reported through `task_complete` in its latest turn, if it made that call. */
+    report(taskId: string): string | undefined;
+    /** The handoff of that call, findings numbered (ADR-0047); undefined when the turn made none, or it handed nothing over. */
+    handoff(taskId: string): StoredHandoff | undefined;
+    /** Recent output of the task's latest capture, or null if it never had one. */
+    liveTail(taskId: string, opts: LiveTailOptions): LiveTail | null;
 }
+
 /**
- * What the controller reports. It never schedules or emits on its own: the
- * orchestrator turns these into observer events and decides what runs next.
+ * The deep module owning all plan-shaped state. Holds `planTasks` (the ordered
+ * tree the user edits), the flattened `allTasks` view and the `taskMap` index.
+ * The orchestrator calls `markCompleted`/`markFailed`/`markInProgress`/`retry`
+ * to update task status — it never mutates task state directly.
+ *
+ * Completion and failure are read from `task.status` and nothing else, so
+ * `isCompleted`, `completedCount`, `isAllComplete` and the scheduler's
+ * dependency checks cannot disagree. The store owns its task objects: `load`
+ * copies what it is given, the getters hand out readonly views, and
+ * `snapshot` is the copy a caller may keep or write to disk.
+ *
+ * `rebuild` is the internal seam that keeps the flat views in sync with the
+ * tree.
+ *
+ * `planRunners` lives here because it's part of the plan's identity (the runner
+ * set, carried on the plan). `assertAssignedRunners` is pure store logic.
  */
-interface IsolationRunListener {
+declare class PlanStore {
+    private _planTasks;
+    private _allTasks;
+    private _taskMap;
+    /** Task id → the top-level task it hangs under, itself for a top-level task. */
+    private _rootMap;
+    private _planRunners;
+    private _onMutate;
+    private _onTree;
+    private _executionLog;
+    /** Hook called after every structural mutation (add/remove/update/resetForRun). */
+    set onMutate(cb: (() => void) | null);
     /**
-     * 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.
+     * Called with every task id, subtasks included, each time the tree is
+     * rebuilt — on every route a task enters or leaves the plan, loads and
+     * reconciled edits included, which `onMutate` does not hear.
      */
-    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;
-    /** Already said through the notifications; also for a surface that shows no toasts. */
-    notice(level: IsolationNoticeLevel, message: string): void;
-}
-interface IsolationRunControllerDeps {
-    isolation: IWorktreeIsolation;
-    config: IConfig;
-    notifications: INotification;
-    workspaceRoot: () => string;
-    listener: IsolationRunListener;
+    set onTree(cb: ((ids: ReadonlySet<string>) => void) | null);
+    get planTasks(): ReadonlyArray<Readonly<Task>>;
+    get allTasks(): ReadonlyArray<Readonly<Task>>;
+    get planRunners(): RunnerId[];
+    get completedCount(): number;
+    get failedCount(): number;
+    isAllComplete(): boolean;
+    isAnyFailed(): boolean;
+    isCompleted(id: string): boolean;
+    isSkipped(id: string): boolean;
+    /** Nothing is left to do: every task completed or was skipped. */
+    isFinished(): boolean;
+    isFailed(id: string): boolean;
+    get(taskId: string): Readonly<Task> | undefined;
     /**
-     * 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.
+     * Whether a task runs as an ops task (ADR-0020): a top-level AI task marked
+     * so, or a script task, which is one by nature (ADR-0035). A subtask runs
+     * with the top-level task it hangs under.
      */
-    liveTasks: () => ReadonlySet<string>;
-}
-/**
- * The lifecycle of a plan's isolation run (ADR-0013, ADR-0014, ADR-0020),
- * between the scheduler and the git layer: deciding, at a run's first change
- * task, whether it executes in worktrees, a blocked run and how it goes on,
- * each attempt's working directory, releasing worktrees, which landed work the
- * user has merged, the tree check of an ops task, the handoff when the run
- * closes, and what the user does with it afterwards. The record it keeps
- * outlives one run — a resumed plan continues it.
- */
-declare class IsolationRunController {
-    private readonly isolation;
-    private readonly config;
-    private readonly notifications;
-    private readonly workspaceRoot;
-    private readonly listener;
-    private readonly liveTasks;
-    private run;
-    /** 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;
-    /** 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;
-    /** 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. Returns the parked start for
-     * the caller to replay; null when nothing was parked.
-     */
-    continueBlocked(how: 'stash' | 'shared'): 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;
+    isOps(taskId: string): boolean;
+    /** Every task's status and what it waits for, to tell cheaply whether one has changed since this was read. */
+    statusMark(): string;
+    /** A copy of the task tree, detached from the store: later status changes do not reach it. */
+    snapshot(): Task[];
+    getExecutionLog(): ReadonlyArray<TaskSnapshot>;
+    appendToLog(snapshot: TaskSnapshot): void;
     /**
-     * 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.
+     * Drop a task's archived snapshot. Un-marking a completion has to erase the
+     * "finished" record too — dependent tasks are prompted from the log, so a
+     * left-behind snapshot would keep feeding them a result that no longer exists.
      */
-    integrate(task: Task, commit?: HandoffCommit): Promise<IsolationOutcome>;
-    /** What a conflict repair's work shows (ADR-0015); git that cannot tell counts against it. */
-    verifyRepair(task: Task): Promise<RepairEvidence>;
+    removeFromLog(taskId: string): void;
+    clearLog(): void;
+    private notifyMutate;
+    private countStatus;
+    load(tasks: ReadonlyArray<Readonly<Task>>, runners: readonly RunnerId[]): void;
+    add(partial: Partial<Task>): Task;
+    remove(taskId: string): void;
+    update(taskId: string, changes: Partial<Task>): Task | undefined;
     /**
-     * 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.
+     * Run preparation as one named op: flip every AI and script task to 'approved'. By
+     * default completed tasks keep their status so a reloaded half-finished plan
+     * resumes the remainder instead of re-running work that already succeeded,
+     * and skipped ones stay skipped: a new run is not a retry of them. A failed
+     * task gets its fresh chance here, not at a load (ADR-0053).
+     * `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.
      */
-    release(taskId: string, opts: {
-        keep: boolean;
-    }, landing?: Promise<unknown> | null): Promise<void>;
+    resetForRun(opts?: {
+        preserveCompleted?: boolean;
+        edited?: boolean;
+        keepFailed?: ReadonlySet<string>;
+    }): 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.
+     * 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.
      */
-    close(): Promise<void>;
+    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;
     /**
-     * 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.
+     * 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.
      */
-    awaitsMerge(taskId: string): boolean;
+    retry(id: string, opts?: {
+        sameRound?: boolean;
+    }): void;
     /**
-     * Look again for landed work the user has merged — by Merge all, or by hand
-     * with git. Resolves true when some was found.
+     * 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.
      */
-    refreshInHead(): Promise<boolean>;
-    /** Mark the run's landed work git finds in HEAD; true when some was found. */
-    private findLanded;
-    /** The run landed something and every landing is in the user's HEAD. */
-    private allMerged;
+    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 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.
+     * 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.
      */
-    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[]>;
+    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;
     /**
-     * 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.
+     * 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.
      */
-    interrupt(opts?: {
-        keepOpen?: boolean;
-    }): void;
+    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;
     /**
-     * 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;
-    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>;
-    /**
-     * 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 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.
-     */
-    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.
+     * 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.
      */
-    private mint;
-    private reportCopies;
-    private reportSetupFailures;
-    private tell;
+    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). */
@@ -953,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';
@@ -969,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 {
@@ -1027,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
@@ -1043,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
@@ -1067,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';
@@ -1085,8 +766,18 @@ declare class Landing {
         outcome: Promise<LandingOutcome>;
     } | null;
     private landConflicted;
-    /** The repair a conflicted task is owed next; null when repair is off, used up, or there is no isolated run to repair it in. */
+    /**
+     * The repair a conflicted task is owed next; null when repair is off, used
+     * up, or there is no isolated run to repair it in. A resolver takes the
+     * conflict instead: a conflict has one worker (ADR-0015).
+     */
     nextRepair(taskId: string): RepairAttempt | null;
+    /**
+     * The tasks in the plan still out to resolve this task's conflict. A skipped
+     * one has been given up, and a link to one that left the plan points at
+     * nothing, so either leaves the conflict free for another worker.
+     */
+    liveResolvers(taskId: string): Readonly<Task>[];
     /** What a repair is asked to do; read once `reopen` has recorded the tips it must bring in. */
     repairPrompt(task: Task): string;
     private hasUnlandedWork;
@@ -1188,7 +879,9 @@ type TaskLogEvent =
 /**
  * A turn began by delivering `message`; `messageId` names it when it had been
  * queued, `forced` when it was force sent. `from` on this and the other
- * message events marks one Ordewell sent rather than the user.
+ * message events marks one Ordewell sent rather than the user. `startedAt`
+ * (ISO) is when it began, which a reload needs to date its open turn (#81);
+ * a log saved before it was kept has none.
  */
  | {
     type: 'turn_start';
@@ -1196,6 +889,7 @@ type TaskLogEvent =
     messageId?: string;
     forced?: boolean;
     from?: TaskMessageFrom;
+    startedAt?: string;
 }
 /**
  * A turn began by running the runner's own command `/name args` (#66): the
@@ -1206,6 +900,7 @@ type TaskLogEvent =
     name: string;
     args?: string;
     messageId?: string;
+    startedAt?: string;
 }
 /** What the running command printed, for one that runs without the model. */
  | {
@@ -1444,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[];
@@ -1453,6 +1197,264 @@ 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';
 /** Read-only view of a task's live attempt. */
 interface TaskAttemptSnapshot {
@@ -1478,9 +1480,10 @@ type StartWait =
     kind: 'started';
 }
 /**
- * A loop's check between rounds (ADR-0045 L3): the loop runs it again, as
- * round `round` of `maxRounds`, once its body has passed and landed;
- * `waiting` is the body that has not yet.
+ * A loop's check between rounds (ADR-0045 L3): it runs again, as round
+ * `round` of `maxRounds`, once its body has passed and landed; `waiting` is
+ * the body that has not yet. Whether anything will run it then is no part
+ * of the rule: a Stop or a reload leaves that to a start of it (L5).
  */
  | {
     kind: 'repeating';
@@ -1492,6 +1495,11 @@ type StartWait =
  | {
     kind: 'completing';
 }
+/** A task added to resolve its conflict has it: a conflict has one worker (ADR-0015). */
+ | {
+    kind: 'resolver';
+    resolver: string;
+}
 /** An AI task with no prompt yet, or a script task with no body to run: there is nothing to run. */
  | {
     kind: 'no-prompt';
@@ -1538,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';
@@ -1554,15 +1567,44 @@ type StartWait =
  * and goes past the whole gate and a planner turn's start hold. Queued behind
  * its dependencies, it starts later with nobody asking, so it waits for a
  * start hold as the scheduler's starts do, and goes past only the gate it was
- * confirmed past: `pastGate`.
+ * confirmed past: `pastGate`. `asScheduled` is one the start rule has already
+ * passed whole, carried back to the queue if it has to wait again.
  */
 type ForcedStart = {
     queued: false;
 } | {
     queued: true;
     pastGate: readonly string[];
+    asScheduled?: true;
 };
 
+type RevertRefusalReason = 'no-landing' | 'no-own-merge' | 'checked-out' | 'in-a-loop' | 'live-dependent' | 'in-branch' | 'git';
+interface RevertRefusal {
+    reason: RevertRefusalReason;
+    message: string;
+    /** `live-dependent`: the tasks in the way. */
+    tasks?: IsolationTaskRef[];
+    /** `in-branch`: what undoes the work there, newest first, for the user to run. */
+    commands?: RevertCommand[];
+}
+/** The tasks a revert would take, the one asked for first; `refusal` says why it may not go ahead, and with no landing there is nothing to take. */
+interface RevertScope {
+    taskIds: string[];
+    refusal?: RevertRefusal;
+}
+/** A task a preview lists; `dependent` is one that goes with the task the user chose, and `ref` how the plan calls it, a subtask's full path. */
+interface RevertPreviewTask extends IsolationRevertTask {
+    dependent: boolean;
+    ref?: string;
+}
+/** What a revert would do now, for a surface to confirm with the user before anything changes. */
+type TaskRevertPreview = {
+    revertible: true;
+    tasks: RevertPreviewTask[];
+} | ({
+    revertible: false;
+} & RevertRefusal);
+
 /** One reported window: what share of it is used, how long it is, and when it resets. */
 interface AccountLimitWindow {
     /** Which of a bucket's windows this is, in the order reported; only a label when the length is unknown. */
@@ -1621,16 +1663,190 @@ declare function accountLimitWindowLabel(window: AccountLimitWindow): string;
 /** `24% used`, `<1% used` for a sliver, `0% used` only when the runner said 0. */
 declare function accountLimitPercentText(percent: number): string;
 /**
- * The compact row: `Codex 5h 24% used · Weekly 61% used`, with any other
- * bucket after its own name, and `(stale)` when the read is not current.
- * Null when there is nothing known to draw.
- */
-declare function accountLimitsText(snapshot: AccountLimitSnapshot): string | null;
+ * The compact row: `Codex 5h 24% used · Weekly 61% used`, with any other
+ * bucket after its own name, and `(stale)` when the read is not current.
+ * Null when there is nothing known to draw.
+ */
+declare function accountLimitsText(snapshot: AccountLimitSnapshot): string | null;
+/**
+ * The row's hover: each window's exact share and reset, the plan, and how
+ * current the read is. `time` words an instant in the reader's clock.
+ */
+declare function accountLimitsTitle(snapshot: AccountLimitSnapshot, time: (at: Date) => string): string;
+
+/**
+ * The bridge between "core needs an answer" and "a human somewhere is looking
+ * at a UI". Core cannot prompt: the human may be at a browser, a TUI, a CLI
+ * stream, or a VS Code webview, and on the web server they are on the far end
+ * of a socket. So the Session parks a promise here, announces the request
+ * through the normal broadcast seam, and every surface answers through the
+ * same `resolve(id, granted)` call.
+ *
+ * Timeouts are load-bearing rather than defensive: a planner turn that blocks
+ * forever on an unanswered prompt would hang the whole research loop with no
+ * visible cause. On expiry the request resolves to denied and the model gets a
+ * normal, actionable tool result. A task runner's request is the exception
+ * (ADR-0018, A1): the runner is parked on it rather than a research loop, and
+ * it waits for a person — or the supervisor — however long that takes.
+ */
+interface PendingApproval {
+    id: string;
+    request: ApprovalRequest;
+    createdAt: string;
+}
+interface PendingApprovalsOptions {
+    /** Denies and resolves after this long with no answer. Default 5 minutes. */
+    timeoutMs?: number;
+    /** Announce a new request to the surfaces. */
+    onRequest?: (pending: PendingApproval) => void;
+    /** Announce that a request is no longer actionable (answered or expired). */
+    onSettled?: (id: string, granted: boolean, settled: {
+        request: ApprovalRequest;
+        decision: ApprovalDecision;
+    }) => void;
+}
+interface AskOptions {
+    /**
+     * An id the caller already announced the request under. One still in use is
+     * refused — denied at once — rather than overwriting the request that has it.
+     */
+    id?: string;
+    /** Wait for an answer however long it takes. */
+    noTimeout?: boolean;
+    /**
+     * Given the answer as the request settles, before anything awaiting the
+     * promise runs: a caller about to tear down what asked (a runner being
+     * stopped) must deliver the answer before it goes.
+     */
+    onDecision?: (decision: ApprovalDecision) => void;
+}
+declare class PendingApprovals {
+    private readonly opts;
+    private readonly entries;
+    private readonly listeners;
+    constructor(opts?: PendingApprovalsOptions);
+    /** Hear each new request once it is announced — the supervisor wakes on a runner's (ADR-0029). */
+    listen(listener: (pending: PendingApproval) => void): () => void;
+    /** Park a request and return the promise the approval policy awaits. */
+    ask(request: ApprovalRequest, options?: AskOptions): Promise<boolean>;
+    /** Park a request whose answer is more than yes or no. */
+    decide(request: ApprovalRequest, options?: AskOptions): Promise<ApprovalDecision>;
+    /**
+     * Answer one request. Returns false when the id is unknown or already
+     * settled. "Allow for this task" on a request that did not offer it is a
+     * plain allow: no grant is made that the requester never proposed.
+     */
+    resolve(id: string, answer: ApprovalAnswer): boolean;
+    /** Everything still awaiting an answer — replayed to a surface that connects late. */
+    outstanding(): PendingApproval[];
+    /**
+     * Deny everything in flight, or only the requests `which` picks. Called on
+     * abort and on session reset.
+     */
+    clear(which?: (request: ApprovalRequest) => boolean, note?: string): void;
+}
+
+/**
+ * What an escalation waits on (ADR-0053). `approval`, `checkpoint`, `input`,
+ * `conflict`, `files-changed` and `usage-limit` are a task's wait; `failed` and
+ * `out-of-rounds` its end; `merge-gate`, `unapproved`, `on-hold`, `no-prompt`
+ * and `by-hand` what alone keeps a task from starting; `merge-all` and
+ * `blocked-run` are the run's own.
+ */
+type EscalationKind = 'approval' | 'checkpoint' | 'input' | 'conflict' | 'files-changed' | 'usage-limit' | 'failed' | 'out-of-rounds' | 'merge-gate' | 'unapproved' | 'on-hold' | 'no-prompt' | 'by-hand' | 'merge-all' | 'blocked-run';
+type EscalationOptionId = 'allow' | 'allow-for-task' | 'deny' | 'approve' | 'reject' | 'reply' | 'resume' | 'continue' | 'retry' | 'run' | 'force-start' | 'skip' | 'complete' | 'merge-all' | 'resolve-conflict' | 'start-resolver' | 'stash' | 'run-without-isolation';
+/** One answer the user may give: what the wait's own card or command offers. */
+interface EscalationOption {
+    id: EscalationOptionId;
+    label: string;
+    /** What this answer does with a note; absent when it takes none. */
+    note?: 'optional' | 'required';
+    /** The question a surface asks first, as it does on the card; the answer then carries the user's yes. */
+    confirm?: string;
+}
 /**
- * The row's hover: each window's exact share and reset, the plan, and how
- * current the read is. `time` words an instant in the reader's clock.
+ * One thing the run waits on a person for, derived and never stored
+ * (ADR-0053). No deadline and no default answer: answering for the user on a
+ * timer is a consent decision, which belongs to the mandate (#23).
  */
-declare function accountLimitsTitle(snapshot: AccountLimitSnapshot, time: (at: Date) => string): string;
+interface Escalation {
+    /**
+     * Kind, task and attempt, then the approval, what a merge gate waits to have
+     * merged, and how many of the attempt's waits ended before it; for Merge all,
+     * the run and the attempts it would merge. A later wait is another
+     * escalation, so a stale answer is told from a live one.
+     */
+    id: string;
+    kind: EscalationKind;
+    /** The task it belongs to, the link to its evidence; absent on the run's own. */
+    task?: {
+        id: string;
+        ref: string;
+        title: string;
+    };
+    /** The attempt it was raised in; absent before any ran. */
+    attempt?: number;
+    /** The runner request it answers, for `approval`. */
+    approval?: string;
+    /** The task out to resolve it, for a `conflict` nothing is starting that task for. */
+    resolver?: string;
+    reason: string;
+    options: EscalationOption[];
+}
+/** What the list reads of the run. */
+interface EscalationRun {
+    /** A full-plan run is scheduling, held, or ended on a failure a retry continues: only then, or in a carried loop, does a task that has not started wait on anyone, a reverted one apart. */
+    open: boolean;
+    /** Something could move a task on unasked, so the seam refuses a Mark complete (ADR-0029). */
+    advancing: boolean;
+    /** A Merge all is under way. */
+    merging: boolean;
+    /** Ordewell merges at gates by itself: the setting is on, and no merge has stopped it. */
+    autoMerges: boolean;
+    /** The run's close merges what landed by itself, so nobody has to; a Stop or a merge that stopped ends this, and the wait is real. */
+    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. */
+    blocked: number | null;
+}
+/** What the list is derived from: nothing here is kept for it. */
+interface EscalationInput {
+    /** The plan tree. */
+    tasks: readonly Task[];
+    /** Every task's start waits; see `planStartWaits`. */
+    waits: ReadonlyMap<string, readonly StartWait[]>;
+    approvals: readonly PendingApproval[];
+    /** The task's latest attempt, 0 before any ran. */
+    attempt: (task: Readonly<Task>) => number;
+    /** An attempt of the task is live, so a runner is there to hear an answer. */
+    live: (taskId: string) => boolean;
+    /** What the task's waiting checkpoint asks, whole. */
+    checkpoint: (taskId: string) => string | undefined;
+    /** Added since the user approved the plan, and left for them (ADR-0035). */
+    waitsForApproval: (taskId: string) => boolean;
+    /** Queued to start with no scheduler, once what holds it clears. */
+    startQueued: (taskId: string) => boolean;
+    /** Why the task is on hold. */
+    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 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;
+}
+/**
+ * Everything that will not move without a person (ADR-0053), in the order of
+ * what stops the most first: a run that cannot start, then the plan's tasks in
+ * order, then the work waiting to be merged. Pure and derived, as `planBlocks`
+ * and `startWaits` are: nothing is stored, so nothing has to be cleared, and it
+ * survives a reload as the waits it reads do.
+ */
+declare function escalations(input: EscalationInput): Escalation[];
 
 type SerializedTaskStatus = {
     id: string;
@@ -1695,6 +1911,8 @@ type SerializedTaskStatus = {
     waitsForApproval?: true;
     /** Why a task is held out of auto-scheduling, in the user's words; absent when it is not held. */
     holdReason?: string;
+    /** A loop's check between rounds that nothing will run, after a Stop or a reload (ADR-0045 L5). Absent for any other task. */
+    loopStranded?: true;
     /** Set only on a research task, so a stream of statuses alone can say which task is one (ADR-0037). */
     research?: true;
     /** The latest attempt's handoff, as the plan keeps it (ADR-0047); absent when the attempt left none. */
@@ -1706,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
@@ -1760,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'> & {
@@ -1862,6 +2084,8 @@ type SessionMessage =
  * digests the turn delivers, shown ahead of the prompt; `supervisor` marks a
  * wake-up turn, which no user message opened (ADR-0029). `forced`: the
  * prompt was force sent, and this turn replaces the one it stopped.
+ * `startedAt` (ISO) is when it began, which a surface counts its elapsed
+ * time from (#81); an older daemon sends none.
  */
  | {
     type: 'planner_turn_started';
@@ -1871,6 +2095,7 @@ type SessionMessage =
     wakeUps?: string[];
     supervisor?: true;
     forced?: true;
+    startedAt?: string;
 } | {
     type: 'planner_skill_loaded';
     turnId: string;
@@ -1981,12 +2206,26 @@ type SessionMessage =
     type: 'planner_compaction';
     compaction: PlannerCompaction;
     turnId?: string;
-} | {
+}
+/**
+ * A planner turn waits for the probe of installed coding agents (ADR-0009),
+ * or nothing does any longer. While `waiting`, no planner has heard of that
+ * turn, so a surface says so rather than that it is planning. It ends with
+ * the probe, whatever became of the turn: one stopped at the gate leaves it
+ * `true` for the next to wait under.
+ */
+ | {
+    type: 'planner_detection';
+    waiting: boolean;
+}
+/** `escalations`: what waits on a person now (ADR-0053), whole; absent from an older daemon. */
+ | {
     type: 'status_update';
     tasks: SerializedTaskStatus[];
     runMerge?: RunMergeView;
     usage?: PlanUsage;
     activity?: RunActivity;
+    escalations?: Escalation[];
 } | {
     type: 'review_needed';
     tasks: SerializedTask[];
@@ -2100,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' | '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[];
@@ -2147,6 +2386,8 @@ interface RunView {
     mergeResult: IsolationMergeResult | null;
     /** What the scheduler is doing with the plan, as {@link RunActivity}. */
     activity?: RunActivity;
+    /** What will not move without a person (ADR-0053), as the newest status update said; absent from an older daemon's snapshot. */
+    escalations?: Escalation[];
 }
 type RunInput = SessionMessage | PlanSnapshot;
 /**
@@ -2162,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): 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;
@@ -2252,9 +2493,11 @@ declare class SessionHeldError extends Error {
 interface SessionLease {
     /**
      * Hold `sessionId`'s lease in `workspace`, letting go of the one held before
-     * only once this one is held. Throws {@link SessionHeldError}.
+     * only once this one is held. Throws {@link SessionHeldError}. `commit` runs
+     * holding both: when it throws, the one held before is still held, and a
+     * lease this claim took is let go.
      */
-    claim(sessionId: string, workspace: string): void;
+    claim(sessionId: string, workspace: string, commit?: () => void): void;
     /**
      * Null while this Session holds `sessionId`'s lease, claiming it when no
      * live host holds it; otherwise who holds it. A lease another host took from
@@ -2335,7 +2578,7 @@ declare class HostedLease implements SessionLease {
     workspace: string;
     private lostLease;
     constructor(host: LeaseHost, onLost: (held: SessionHeld) => void);
-    claim(sessionId: string, workspace: string): void;
+    claim(sessionId: string, workspace: string, commit?: () => void): void;
     hold(sessionId: string, workspace: string): SessionHeld | null;
     release(): void;
     /** @internal Another host took `file`'s lease from this one. */
@@ -2348,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';
@@ -2357,10 +2709,12 @@ type AutoMergeTrigger = {
 };
 /**
  * Who opened a run (ADR-0029): a call the user made, or one made for them; a
- * call of the supervisor's own; or a usage-limit reset resuming what it paused.
- * Only the user's starts a run's supervision afresh.
+ * call of the supervisor's own, or a subplanner's, which has no user to make
+ * one for (ADR-0056 M6); a usage-limit reset resuming what it paused; or a loop
+ * carried on with no scheduler (ADR-0045 L5). Only the user's starts a run's
+ * supervision afresh.
  */
-type RunOrigin = 'user' | 'supervisor' | 'limit-reset';
+type RunOrigin = 'user' | 'supervisor' | 'limit-reset' | 'loop';
 /** What the scheduler reads of the open run's settings, at each decision it makes from them. */
 type SchedulerRunSettings = Pick<RunSettings, 'mergeAtGatesAutomatically'>;
 /**
@@ -2485,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). */
@@ -2518,8 +2874,14 @@ interface TaskOrchestratorDeps {
      * owns it, and the scheduler starts nothing outside it.
      */
     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. */
@@ -2529,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
@@ -2538,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;
@@ -2559,7 +2971,11 @@ interface TaskOrchestratorOptions {
     plannedWith?: () => boolean;
     /** Every task is approved unless a Session supplies its record: an orchestrator on its own has no user to ask. */
     isApproved?: (taskId: string) => boolean;
+    /** 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;
@@ -2569,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},
@@ -2583,6 +3023,7 @@ interface TaskOrchestratorOptions {
  * and does not unblock dependent work.
  */
 declare class TaskOrchestrator {
+    private readonly deps;
     private config;
     private notifications;
     private store;
@@ -2592,12 +3033,20 @@ declare class TaskOrchestrator {
     private runState;
     /** Planner turns in flight that new starts wait for (ADR-0029); running attempts carry on. */
     private startHolds;
+    /** The judgement a {@link judgingOnce} read shares, while one runs. */
+    private judgement;
+    /** The {@link revertReach} of each revert under way: unlike a hold, it stops a start admitted before the revert too. */
+    private readonly reverting;
     /** Bumped by the user's Stop: a start admitted under an older generation never takes its claim. */
     private stopGeneration;
     /** Starts admitted and not yet claimed or let go; see {@link StartAdmission}. */
     private admissions;
     private reviewApproved;
     private autoMergeBlocked;
+    /** 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). */
@@ -2628,6 +3077,18 @@ declare class TaskOrchestrator {
     private queuedStarts;
     /** Conflict repairs owed with every slot taken and no scheduler to claim them: a freed slot starts them. */
     private owedRepairs;
+    /**
+     * The checks whose loop goes on with no scheduler: each failed a round in a
+     * run the scheduler was not driving, so nothing else would start what it
+     * owes (ADR-0045 L5). Held here and not on the plan, because a Stop ends it
+     * and a reload does not bring it back; an edit does neither. A loop stopped
+     * 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;
     /**
      * Tasks Mark complete is landing after it ended their attempt, or that
      * their conflict resolver is landing, and that landing: in progress with
@@ -2639,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
@@ -2646,12 +3114,18 @@ 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;
     private previousRounds;
     private runSettings;
     private isApproved;
+    private mayMergeUnasked;
     constructor(deps: TaskOrchestratorDeps);
     /**
      * The composition root: resolves every optional collaborator and wires the
@@ -2670,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
@@ -2719,6 +3195,10 @@ declare class TaskOrchestrator {
     get isReviewApproved(): boolean;
     /** The scheduler is driving the plan: ready tasks start on their own as slots free. Narrower than {@link isRunning}. */
     get isScheduling(): boolean;
+    /** A scheduled run, driving the plan or held by a usage limit that gives it back: a hold never closes one. */
+    get scheduledRun(): boolean;
+    /** A usage limit holds the run, whatever it goes back to at the reset. */
+    get runHeld(): boolean;
     /**
      * A full-plan run with nothing starting that something still resumes: a
      * usage limit's reset, or a retry of a failed task its blocked tasks wait on.
@@ -2729,6 +3209,8 @@ declare class TaskOrchestrator {
     /** Task id → session id of every attempt whose runner is up; a spawn in flight has no session yet. */
     get activeSessionMap(): Map<string, string>;
     getAttempt(taskId: string): TaskAttemptSnapshot | undefined;
+    /** The number of the task's latest attempt, live or ended; 0 before any ran. */
+    latestAttempt(task: Readonly<Task>): number;
     /** A planner turn holds new starts: what is ready starts when it releases them. */
     get startsHeld(): boolean;
     /**
@@ -2748,11 +3230,20 @@ declare class TaskOrchestrator {
      * Something can still start that nobody has to ask for again: a start
      * 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, or a start a
-     * dirty checkout parked for Stash and continue to replay. A Stop is owed to
-     * it, whether or not anything runs.
+     * 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 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}.
      */
     get startsPending(): boolean;
+    /**
+     * A loop is carried on, one a body task stopped included. Nothing of that
+     * one starts by itself, so nothing here moves a task on, but a retry that
+     * passes would resume it: a Stop is owed to it too (ADR-0045 L7).
+     */
+    get loopCarried(): boolean;
     /**
      * The plan's activity as one word for every surface: a start on its way,
      * work running, a scheduler driving the plan, or a run that resumes by
@@ -2772,7 +3263,9 @@ declare class TaskOrchestrator {
      */
     get advancesOnItsOwn(): boolean;
     /** A start admitted now that nothing has to count as live work: one that claims before it awaits, or follows on from one that did. */
-    private admittedNow;
+    admittedNow(): Admitted;
+    /** The user's Stop found nothing to stop: it still withdraws every start admitted before it, one no live work counts included (ADR-0029). */
+    stopAsked(): void;
     /** Run `work`, which awaits before it claims, under an admission it holds throughout and claims under. */
     private whileAdmitted;
     /**
@@ -2790,6 +3283,15 @@ 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
+     * name a Merge all it is about to do itself (ADR-0053). A Stop takes the run
+     * out of isolating and a merge that stopped blocks this, so neither wait is hidden.
+     */
+    get mergesAtClose(): boolean;
     /**
      * The run as a surface offers Merge all mid-run (ADR-0020): what has landed
      * and is not merged, and whether the run is paused at its gates with nothing
@@ -2812,9 +3314,48 @@ declare class TaskOrchestrator {
      * Takes the task, not its id: the one the command seam located.
      */
     startWaits(task: Readonly<Task>, forced?: ForcedStart): StartWait[];
+    /** Every task's {@link startWaits}, the plan judged once. */
+    planStartWaits(): Map<string, StartWait[]>;
+    /**
+     * Run `read`, a synchronous read of the plan, on one judgement of it: what a
+     * read asks task by task would otherwise judge the whole plan per task.
+     * Nothing can change the plan inside it, so no answer can be stale.
+     */
+    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
+     * keeps it. The words are for whoever asked, since a surface may still offer
+     * the action from a status update it has not yet replaced.
+     */
+    resolverRefusal(taskId: string): string | null;
+    /** What the conflict repair this task is owed waits for; null when no repair will start by itself. */
+    repairWait(taskId: string): RepairWait | null;
+    /** A usage limit keeps this task from starting by itself: the hold on the run, or its own runner's limit with no reset to wait for. */
+    private onUsageLimit;
+    /** Where a task's isolated work stands, and who has its conflict: the record says the first, the scheduler the second. */
+    taskIsolation(taskId: string): TaskIsolation | null;
+    /** Each task's isolation mark and the run's handoff, as {@link taskIsolation} reads them. */
+    isolationView(): IsolationView | null;
+    private withConflictWorker;
+    /**
+     * A repair will start by itself: the task is not started, it has one left,
+     * and something will claim it, the scheduler or {@link owedRepairs}. Nothing
+     * saves this: a reload or a Stop leaves the conflict waiting on the user.
+     */
+    private owesRepair;
     /** The failed tasks a task not started yet waits on, through its dependencies (ADR-0034); empty when it is not blocked. */
     getBlockedBy(taskId: string): string[];
+    /** Throws what {@link loadPlan} would, for a caller with work of its own to do before it loads. */
+    assertLoadable(tasks: readonly Task[], planRunners?: RunnerId[]): void;
     /**
      * `edited`: the plan is the last one edited, not a new one. Only a Stop
      * withdraws a queued start (ADR-0035), so one of a task the edit keeps
@@ -2828,8 +3369,9 @@ declare class TaskOrchestrator {
      * reload would clear the holds and the review approval, so a task the user
      * cancelled would be re-armed by the tick that follows, and a retry after
      * the edit would run the failed task alone, its failure lost. Otherwise it
-     * is the plan the next run starts from, with what waits on a usage-limit
-     * reset still waiting: an edit between runs is not the user starting over.
+     * is the plan the next run starts from, with a failed task still failed and
+     * what waits on the user still waiting: an edit between runs is not the user
+     * starting over.
      */
     adoptEdit(tasks: readonly Task[], planRunners: RunnerId[]): void;
     /**
@@ -2844,37 +3386,51 @@ declare class TaskOrchestrator {
      * input it waits at — adopting the snapshot's "pending" would offer the
      * scheduler work a runner is already doing.
      *
-     * A failed task stays failed, unlike a plan load's fresh chance: an edit is
-     * not a retry, and the tasks it blocks wait for that retry (ADR-0034).
+     * A failed task stays failed: an edit is not a retry, and the tasks it blocks
+     * wait for that retry (ADR-0034). One the edit made manual has no retry to wait for.
      */
     reconcilePlan(newTasks: readonly Task[], planRunners?: RunnerId[]): void;
     /**
      * An edit landed on the plan — a planner's task ops through
      * {@link reconcilePlan}, or the user's direct edit through the PlanEditor.
-     * One that leaves a loop's check out of rounds ends the loop (ADR-0045 L6):
-     * what of its body has not run will not run, and, while the run is under
-     * way, the check settles once more so the supervisor hears the end. Nothing
-     * else notices such an edit: the check settled when it failed a round, and
-     * no round will run it again.
+     * A task it made manual is the manual task it now is (ADR-0053), a runner
+     * still at a question apart. One that leaves a loop's check out of rounds
+     * ends the loop (ADR-0045 L6): what of its body has not run will not run,
+     * and, while the run is under way, the check settles once more so the
+     * supervisor hears the end. Nothing else notices such an edit: the check
+     * settled when it failed a round, and no round will run it again.
      */
     planEdited(before: readonly Task[]): void;
     /**
-     * Begin the full-plan run afresh, as Execute does with nothing at work.
-     * Whatever an earlier run left goes: its state, even held or armed with
-     * nothing live, which {@link start} would take as a run already under way;
-     * its scheduled resumes and execution log; and, as the plan is loaded over
+     * Begin the full-plan run afresh, as Execute does with no open run to join.
+     * Whatever an earlier run left goes: its state, which {@link start} would
+     * take as a run already under way; its scheduled resumes and execution log;
+     * and, as the plan is loaded over
      * itself, its retry counts, holds, loop rounds and review approval. Every
      * task not done is ready to run again, and the scheduler starts it; a plan
-     * with nothing left to run ends at once, and the scheduler says so.
+     * with nothing left to run ends at once, and the scheduler says so, but for
+     * `keepFailed`: failures nobody asked this run to try again (ADR-0030).
      */
-    beginRun(origin: RunOrigin): Promise<void>;
+    beginRun(origin: RunOrigin, keepFailed?: ReadonlySet<string>): Promise<void>;
     /**
      * Take the plan into the run under way (#95), whose tasks were approved
      * first: a scheduled run starts them as their dependencies finish, and one
      * the scheduler was not driving — tasks started on their own — becomes the
-     * plan's run, as Execute would make it.
+     * plan's run, as Execute would make it. A hold starts nothing either way:
+     * the plan's run is what its reset gives back (ADR-0018 U1). A start a dirty
+     * checkout parked in a scheduled run is replayed, which reads the checkout
+     * again; a new run would take back the run's failures (ADR-0053).
      */
     joinRun(origin: RunOrigin): Promise<void>;
+    private joinHold;
+    /**
+     * The user's Execute takes in work the scheduler was not driving: it becomes
+     * the plan's run, so what failed gets the fresh chance Execute gives
+     * (ADR-0053). A scheduled run keeps its failures, which a retry continues
+     * (ADR-0034), and Execute only approves what waits in it: a hold that gives
+     * one back is that run still.
+     */
+    readyFailed(): void;
     /** Start the full-plan run, or continue one that is held or ended on a failure. */
     start(origin?: RunOrigin): Promise<void>;
     /**
@@ -2884,6 +3440,18 @@ declare class TaskOrchestrator {
      * for meanwhile.
      */
     stop(reason?: 'user' | 'restart'): void;
+    /**
+     * Nothing claims a repair once the run has stopped, so what was owed one is
+     * a conflict waiting on the user, listed with its options, not a task that
+     * reads as never started.
+     */
+    private withdrawRepairs;
+    /**
+     * A force start behind a dependency lifted a reverted task's hold for that
+     * start alone, in the queue or left to the scheduler. With the start
+     * withdrawn, the task stays what the user took back (ADR-0054).
+     */
+    private withdrawQueuedStarts;
     private chosenHoldsNow;
     private restoreHolds;
     private releaseUnchosenHolds;
@@ -2941,17 +3509,34 @@ 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
      * the slot the ending attempt freed and never one more than the run allows.
-     * A planner turn's start hold holds it as it holds any new spawn (ADR-0029).
-     * The repair follows on from the start whose work it repairs: a Stop since
-     * that was admitted withdraws it.
+     * A planner turn's start hold holds it as it holds any new spawn (ADR-0029),
+     * and a usage limit does too: `reopen` spends a repair, so one the runner
+     * would refuse is not tried. The repair follows on from the start whose work
+     * it repairs: a Stop since that was admitted withdraws it.
      */
     private settleUnlanded;
     /** Start the repairs {@link settleUnlanded} left owed, as slots and any start hold allow. */
     private startOwedRepairs;
+    /**
+     * A conflict ended some other way than through its resolver: the task
+     * landed, was retried or skipped, or left the plan. The merge the resolver
+     * was added for is no longer needed, so it goes with its link: skipped,
+     * with why, and never started (ADR-0015).
+     */
+    private retireResolvers;
+    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;
     /**
      * Hold a task for as long as `landing` is merging its worktree. Its end lets
@@ -2962,6 +3547,10 @@ declare class TaskOrchestrator {
     getReadyTasks(): Task[];
     private readiness;
     private mergesAutomatically;
+    /** A Merge all is under way. */
+    get isMerging(): boolean;
+    /** A gate reached now is merged with nobody asked: the setting is on, and no merge has stopped it. */
+    get mergesAtGates(): boolean;
     /**
      * The user changed the run settings under an open run (ADR-0030). The
      * scheduler reads them at each decision it makes from them, so a merge gate
@@ -2996,6 +3585,7 @@ declare class TaskOrchestrator {
      * Cancel a running (or scheduled) task: kill its session and return it to
      * 'pending' — "not executed". The task is put on hold so the scheduler
      * doesn't immediately restart it; Retry / Force Start release the hold.
+     * A repair, running or owed a start, leaves its conflict waiting instead.
      *
      * The attempt's worktree is kept, as a stopped or failed one is: a runner is
      * often cancelled because it looked stuck after doing the work, and Mark
@@ -3031,6 +3621,33 @@ declare class TaskOrchestrator {
      * to waiting on their own, because the scheduler gates on `isCompleted`.
      */
     markTaskIncomplete(taskId: string): Promise<void>;
+    /**
+     * What reverting a task would take, and what stands in its way, as far as
+     * the plan can say (ADR-0054); {@link revertPreview} and the revert itself
+     * ask git the rest.
+     */
+    revertScope(taskId: string): RevertScope;
+    /** What a revert of the task would do now: the tasks, newest landing first, or why it would not go ahead. */
+    revertPreview(taskId: string): Promise<TaskRevertPreview>;
+    /**
+     * Revert the task's landed work, with its landed dependents, on the
+     * integration branches (ADR-0054). No new start while it waits for its
+     * turn and works: one that took its claim now would be cut from a tip about
+     * to lose what it depends on, so the claim of anything depending on the work
+     * is refused too, a start admitted before the revert with it. What it finds
+     * in the way there is judged again: a Mark complete landing a dependent is
+     * live like any other. Tasks not depending on it keep running.
+     */
+    revertTask(taskId: string): Promise<IsolationRevertResult>;
+    private revertRefusalNow;
+    /**
+     * Each reverted task goes back to not started, held like a stopped one so
+     * the scheduler does not run it again, and starts over when retried: from
+     * the current tip, which no longer holds its work. Its completion goes as
+     * Mark not done takes one back; the logs of its attempts stay. A conflict it
+     * held is over, so a resolver out to it goes too (ADR-0015).
+     */
+    private takeBack;
     /**
      * Skip: end a task as `skipped`, with no verdict and nothing of its work
      * landed. Its worktree is kept, as a failed attempt's is, so the user can
@@ -3047,8 +3664,10 @@ declare class TaskOrchestrator {
      * the task ended in rather than a fresh one given its prompt again. The
      * worktree keeps the same path, where the runner keeps its sessions, and
      * restores the previous work so that session's memory matches its files.
+     * `revives` is {@link claimRefusal}'s, read as the start is asked for: a dirty
+     * tree's replay carries the first answer, not one read after a skip.
      */
-    continueTask(taskId: string, message: string, origin?: RunOrigin): Promise<void>;
+    continueTask(taskId: string, message: string, origin?: RunOrigin, revives?: boolean): Promise<void>;
     /**
      * Keep a task paused on its runner's usage limit from resuming on its own:
      * it waits for a manual retry, as one whose reset time could not be read
@@ -3111,9 +3730,9 @@ declare class TaskOrchestrator {
      * Reuses the scheduler's own claim so a force-started task gets the same
      * augmented prompt, session tracking, and exit handling — callers must not
      * re-spawn the runner themselves. No-op if the task is unknown, a user
-     * task, or already running.
+     * task, or already running. `revives` is as on {@link continueTask}.
      */
-    forceStartTask(taskId: string, origin?: RunOrigin): Promise<string | undefined>;
+    forceStartTask(taskId: string, origin?: RunOrigin, revives?: boolean): Promise<string | undefined>;
     /**
      * Start an approved task once its merge gate opens, never past it: a script
      * task `run_script` added behind work not merged into the user's branch yet
@@ -3122,6 +3741,17 @@ declare class TaskOrchestrator {
      * so it starts once Merge all has merged that work, and a Stop withdraws it.
      */
     startAtGate(taskId: string): void;
+    /** A start of this task waits in the queue, and starts with nobody asked once what holds it clears. */
+    startQueuedFor(taskId: string): boolean;
+    /**
+     * Start a task the user's own act asked for, under the one start rule and
+     * past none of it (ADR-0015). A scheduler driving the run claims it as it
+     * would any task; otherwise it waits with the queued starts for a slot, a
+     * start hold or a usage limit, says what holds it, and a Stop withdraws it.
+     * A conflict repair is started the same way, and this is what a resolver
+     * added outside a run has in place of one.
+     */
+    startWhenAllowed(taskId: string): void;
     /**
      * A forced start, from its run opening to its claim. It is judged again once
      * the run has opened, against the task as it stands then, which is what
@@ -3160,8 +3790,53 @@ 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;
+    private sayOnce;
     private refuseOpsDuringMerge;
     /**
      * A force start passes a merge gate (ADR-0020), and the surface confirmed it
@@ -3175,6 +3850,29 @@ 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;
     /**
      * The one step that decides, with nothing at work and nothing the scheduler
      * can start, whether the run goes on, is held, waits on the user or is over
@@ -3182,9 +3880,18 @@ declare class TaskOrchestrator {
      * only an end emits it. A run the scheduler is not driving — tasks started
      * on their own — ends on a verdict; a cancel, Mark complete or failed spawn
      * just closes it, so the next run decides its own mode rather than inherit
-     * this one's.
+     * this one's. A loop carried on outside a scheduled run holds that run open
+     * 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,
      * a round starts: its body runs again as new attempts, each from the
@@ -3192,7 +3899,9 @@ declare class TaskOrchestrator {
      * the failure is the round's, not the task's. Approval is not spent by a
      * run, so the plan's approval of the body covers every round. Out of
      * rounds, the body still to run will not run. A body task the user skipped
-     * has stopped the loop (L7): no round starts, and the skip stands.
+     * has stopped the loop (L7): no round starts, and the skip stands. One they
+     * reverted keeps its hold, which a round takes as any start does (L5, ADR-0054):
+     * the rest of the body runs, and the loop waits for them to say.
      */
     private startRound;
     /**
@@ -3208,6 +3917,53 @@ declare class TaskOrchestrator {
      * complete, a reload in between — resumes the loop alike.
      */
     private repeatChecks;
+    private repeatCheck;
+    /**
+     * Something will run this check between rounds without being asked: a
+     * scheduler, the one a reset gives back, or its loop carried on (ADR-0045
+     * L5). What the seam reads before it says so to anyone.
+     */
+    loopRunsOn(checkId: string): boolean;
+    /** A start of this task would be its loop's next round: between rounds, its body landed, and nothing else will run it. */
+    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 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
+     * them itself, or while a usage limit holds the run, which starts nothing.
+     * 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: what is carried on, and nothing that depends on it. */
+    carriedTasks(): Set<string>;
+    /**
+     * 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. */
     private sayFinished;
     /** How a run that ended on failures ends: what it finished, what failed, and what that blocks. */
@@ -3222,11 +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, 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.
+     * 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), 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. */
@@ -3234,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:
@@ -3247,9 +4017,10 @@ declare class TaskOrchestrator {
     /**
      * Replay the start a dirty tree turned away. `stash` puts the user's tracked
      * changes on the git stash first, so the run isolates; `shared` runs this one
-     * run in the workspace root, knowingly.
+     * run in the workspace root, knowingly; `reread` reads the tree again, which
+     * may turn the start away again.
      */
-    continueBlockedRun(how: 'stash' | 'shared'): Promise<void>;
+    continueBlockedRun(how: 'stash' | 'shared' | 'reread'): Promise<void>;
 }
 
 /** One call at the command seam, as every route words it (ADR-0029). Task references are resolved here. */
@@ -3293,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. */
  | {
@@ -3325,6 +4097,18 @@ type ExecutionCommand = {
     confirmed?: boolean;
     seen?: TaskStatus;
 }
+/**
+ * The user takes a task's landed work off the integration branch, before
+ * Merge all, with its landed dependents (ADR-0054). Needs `confirmed`, their
+ * yes to what the preview listed; `seen` is the task ids it listed, and a
+ * set that changed since is refused.
+ */
+ | {
+    command: 'revert_task';
+    task: string;
+    confirmed?: boolean;
+    seen?: string[];
+}
 /** Stop a structured task's running turn, keeping its session: it then waits for the user's message. */
  | {
     command: 'interrupt_task';
@@ -3357,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. */
  | {
@@ -3398,6 +4183,16 @@ type CommandPayload =
  | {
     kind: 'merge';
     result: IsolationMergeResult;
+}
+/** The user's `revert_task`, reverted or stopped: which tasks, or the task and files, or the commands that do it by hand. */
+ | {
+    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,
@@ -3429,19 +4224,6 @@ type Consent = {
  * body is never covered.
  */
 type EffectAllowlist = (body: ScriptBody) => string | null;
-/**
- * What a supervisor at `level` may do. The mandate (#23) replaces this check;
- * nothing above it moves.
- */
-type SupervisorPolicy = (level: SupervisorLevel, command: ExecutionCommandName) => Consent;
-/**
- * The supervisor levels (ADR-0029). Off: it does not act. Watch: it reads and
- * suggests, and every execution command it calls is refused. Act: every
- * command runs without asking — choosing Act is the consent — inside the loop
- * guards; what a command may never do, like allowing an approval, is still
- * refused by the command itself.
- */
-declare const SUPERVISOR_LEVELS: SupervisorPolicy;
 /**
  * A check that stops an actor spinning (ADR-0029's loop guards): the trip —
  * the note naming the guard and what would be accepted, and what the user is
@@ -3470,6 +4252,8 @@ interface ExecutionHost {
     waitsForApproval(taskId: string): boolean;
     /** A start the user consented to approves these tasks, before it acts. */
     approve(taskIds: readonly string[]): void;
+    /** A start under Full with autorun makes the plan approved, as autorun's own start does, so nothing later in the session is refused for it (ADR-0030). */
+    approvePlan(): void;
     /** Full autonomy: starts follow plan approval without a question. */
     autonomous(): boolean;
     /** The user's autorun setting, as it is now (ADR-0030). */
@@ -3480,17 +4264,35 @@ interface ExecutionHost {
     startsHeld(): boolean;
     /** Work is running right now. */
     hasLiveWork(): boolean;
+    /** A usage limit holds the run: what it paused resumes at the reset. */
+    runHeld(): boolean;
+    /** A scheduled run is open, driving the plan or held by a usage limit that gives it back, whether or not anything is live. */
+    scheduledRun(): boolean;
     /** Something will start without being asked again: a start admitted and not yet claimed, or a scheduled resume. */
     startsPending(): boolean;
+    /** A plan the turn in flight submitted, whose start autorun makes as the turn ends (ADR-0030): a start on its way that no run holds yet. */
+    submittedStartWaits(): boolean;
+    /** A loop is carried on, one a body task stopped included; see {@link TaskOrchestrator.loopCarried}. */
+    loopCarried(): boolean;
+    /** A run with nothing starting that something still resumes: a usage limit's reset, or a retry of a failure; see {@link TaskOrchestrator.awaitsResume}. */
+    awaitsResume(): boolean;
+    /** Something will run this loop's check between rounds without being asked; see {@link TaskOrchestrator.loopRunsOn}. */
+    loopRunsOn(taskId: string): boolean;
     /** Something could move a task on without being asked: a start, an attempt in any phase, the scheduler or a usage-limit hold. */
     advancesOnItsOwn(): boolean;
     /** Admit a start that waits before it claims; see {@link StartAdmission}. */
     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.
@@ -3507,15 +4309,29 @@ interface ExecutionHost {
      * `left` still wait. Answers the line that says so.
      */
     joinRun(approved: number, left: number): Promise<string>;
+    /** The fresh chance the user's Execute gives what failed, for work it takes in (ADR-0053); none while the scheduler drives the run. */
+    readyFailed(): void;
     startTask(taskId: string, actor: ExecutionActor): Promise<void>;
     /** Force start the task; answers the line saying it waits for its dependencies, when it was queued behind them rather than started. */
     forceStart(taskId: string): Promise<string | undefined>;
     markComplete(taskId: string): Promise<void>;
     markNotDone(taskId: string): Promise<void>;
+    /** What reverting the task would take, as far as the plan can say; see {@link TaskOrchestrator.revertScope}. */
+    revertScope(taskId: string): RevertScope;
+    /** Revert the task's landed work, through the queue it shares with landings. */
+    revertTask(taskId: string): Promise<IsolationRevertResult>;
     interrupt(taskId: string): Promise<void>;
-    stopTask(taskId: string): Promise<void>;
-    stopRun(): void;
+    /** `actor` is who stopped it: the user's stop holds the supervisor back from it (ADR-0029). */
+    stopTask(taskId: string, actor: ExecutionActor): Promise<void>;
+    /** `actor` is who stopped it: the user's Stop stands the supervisor down (ADR-0029). */
+    stopRun(actor: ExecutionActor): void;
+    /** The user's Stop found nothing to stop: what was admitted before it is withdrawn all the same. */
+    stopAsked(): void;
+    /** 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>;
@@ -3532,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. */
@@ -3568,6 +4388,12 @@ interface ExecutionHost {
     awaitEnd(taskId: string, ms: number, signal?: AbortSignal): Promise<void>;
     /** The task's result is owed to the planner, in a turn acting for whoever started it (ADR-0037, R2, R3). */
     owe(taskId: string, to: TaskReportTo): void;
+    /** What waits on a person now, derived afresh (ADR-0053). */
+    escalations(): readonly Escalation[];
+    /** Add the task that merges a conflicted task's branch by hand; false when it has no conflict left. */
+    resolveConflict(taskId: string): Promise<boolean>;
+    /** Replay the run a dirty checkout turned away, stashing first or for this run without isolation. */
+    continueRun(how: 'stash' | 'shared'): Promise<void>;
     /** The end of a task's output, as a planner turn is told it; see {@link taskReport}. */
     reportTail(taskId: string): string | undefined;
 }
@@ -3575,7 +4401,8 @@ interface ExecutionCommandsDeps {
     host: ExecutionHost;
     /** The approval card channel a Guarded start asks through. */
     consent: Pick<IApproval, 'request'>;
-    supervisor?: SupervisorPolicy;
+    /** What this node may do unasked, read at each check (ADR-0056 M1); a root with nothing past what the host says unless set. */
+    authority?: NodeAuthority;
     guards?: readonly LoopGuard[];
     /** What pre-approves a script's effect (ADR-0035); nothing does unless set. */
     effects?: EffectAllowlist;
@@ -3595,7 +4422,7 @@ interface ExecutionCommandsDeps {
 declare class ExecutionCommands {
     private readonly deps;
     private readonly host;
-    private readonly supervisor;
+    private readonly authority;
     private readonly guards;
     private readonly effects;
     private readonly now;
@@ -3619,6 +4446,15 @@ declare class ExecutionCommands {
      * committed, its own edits in the turn included (ADR-0022 P2).
      */
     run(asked: ExecutionCommand, actor: ExecutionActor, signal?: AbortSignal): Promise<CommandOutcome>;
+    /**
+     * The user's answer to an escalation (ADR-0053): the list derived afresh,
+     * and the option chosen dispatched to the existing command for that wait, as
+     * the user, so every check it has still applies and this adds no authority.
+     * It takes no actor because it is the user's alone: no planner tool reaches
+     * 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, 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;
     /**
@@ -3641,28 +4477,32 @@ 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;
     /**
-     * Who may run a script without the mandate (#23), as ADR-0035's table says.
-     * An effect the user's allowlist covers runs in every row but one, and is
-     * recorded by its rule. In the user's turn: otherwise autorun in Full runs
-     * it (ADR-0030), and failing that they are asked on the card. The
-     * supervisor's level decides for it first: at Watch it is refused, to
-     * suggest it instead, covered or not; at Act it runs, the task it adds
-     * being approved (ADR-0029).
+     * Who may run a script, as ADR-0035's table says. An effect the user's
+     * allowlist covers runs in every row but one, and is recorded by its rule.
+     * In the user's turn: otherwise autorun in Full runs it, on a first plan as
+     * on an approved one (ADR-0030), and failing that they are asked on the
+     * card. The supervisor's level decides for it first: at Watch it is refused,
+     * to suggest it instead, covered or not; at Act it runs, the task it adds
+     * being approved (ADR-0029). A subplanner's is its grants alone (ADR-0056 M6).
      */
     private scriptConsent;
     /**
-     * Of the tasks a planner edit in the user's turn wrote, the ones autorun
-     * approves as the edit commits: all of them, but for a script task, which
-     * runs unasked only where `run_script` would run it unasked (ADR-0035), so
-     * under Guarded it waits for the user unless their effect allowlist covers
-     * it. Its row shows the body verbatim, and starting it is their consent.
+     * Of the tasks a planner edit wrote, the ones autorun approves as the edit
+     * commits. Under Full every one of them, a rewritten script's new body
+     * included, for the user's turn and a supervisor at Act alike. Otherwise only
+     * in the user's turn, and all but a script task, which runs unasked only
+     * where `run_script` would run it unasked (ADR-0035), so under Guarded it
+     * waits for the user unless their effect allowlist covers it. Its row shows
+     * the body verbatim, and starting it is their consent. Below the root this
+     * is the `approve` grant (ADR-0056 M6).
      */
-    autorunApproves(written: readonly Readonly<Task>[]): string[];
+    autorunApproves(actor: ExecutionActor, written: readonly Readonly<Task>[]): string[];
     /**
      * A task `run_script` answered for before it ended has ended: its result
      * joins the timeline beside its start, with who asked and how it was
@@ -3674,16 +4514,22 @@ declare class ExecutionCommands {
      * The tasks a start approves, read from the plan as it stands at the
      * command's last check. Autorun starts a plan as the user's standing
      * instruction, so its start approves what it runs as the user's does; so
-     * does a start under its exception for added tasks. A yes on the card
-     * approves the tasks the card named, and no others.
+     * does a start under Full with autorun. Under Guarded it leaves a script task
+     * the commit left unapproved: that waits for the user (ADR-0035). A yes on
+     * the card approves the tasks the card named, and no others.
      */
     private consented;
     /**
-     * With autorun on and Full, a planner turn may start a task added after the
-     * user approved the plan (ADR-0030). Read at each start, so switching either
-     * off stops it at once; never on a plan the user has not approved.
+     * With autorun on and Full, nobody is asked: a planner turn, or a supervisor
+     * its level lets act, may start anything, on a first plan as on an approved
+     * one (ADR-0030). Read at each start, so switching either off stops it at
+     * once. Below Act the level has refused the call before this is read. A
+     * subplanner has nobody to ask, so `approve` alone says it: its `autonomy`
+     * says what its runners may do, not whether a person is asked (ADR-0056 M7).
      */
-    private addedMayStart;
+    private startsUnattended;
+    /** The mandate that answers for `actor` now: read at each check, so a change reaches the next one (ADR-0056 M1). */
+    private mandateOf;
     /**
      * Guarded means "ask the user first": a planner start in the user's own
      * turn asks, so tasks they have not approved go into the question rather
@@ -3692,12 +4538,23 @@ declare class ExecutionCommands {
      */
     private asksToApprove;
     /**
-     * Who may do what without the mandate (#23): the user's own call needs no
-     * consent, and their own controls are theirs alone; a planner turn may
-     * always end or steer work, and starts it only as the autonomy level says;
-     * the supervisor's level decides for it.
+     * Who may do what, in the one place it is decided (ADR-0056 M6): the user's
+     * own call needs no consent, and their own controls are theirs alone; a turn
+     * the user opened keeps ADR-0029's table, since a person needs no mandate: it
+     * may always end or steer work, and starts it only as the autonomy level says.
+     * The supervisor's level decides for it through its mandate, and a subplanner
+     * has its grants alone, allow or refuse: nobody is there to ask.
+     */
+    consent(actor: ExecutionActor, command: ExecutionCommandName): Consent;
+    private supervisorConsent;
+    private grantConsent;
+    /**
+     * Autorun is the user's standing instruction, so at the root it is not held
+     * to a level: Watch has no `control`, and autorun still starts its plan. Below
+     * the root there is no user behind it, and `approve` and `control` narrow it
+     * (ADR-0056 M6).
      */
-    private consent;
+    private autorunConsent;
     /**
      * A checkpoint asks a person for judgement on the work, so the user answers
      * it from the task's card; the supervisor may only at Act, in a wake-up turn
@@ -3712,8 +4569,16 @@ declare class ExecutionCommands {
      */
     private prepare;
     private prepareRunPlan;
+    /**
+     * What a planner is told of its `run_plan`: it leaves a failure as it is
+     * (ADR-0053), so the line says so, and where nothing was left to start the
+     * run has ended again and the line does not say it runs.
+     */
+    private runningLine;
     /** A start of one task: `run_task`, or a fresh `retry_task`, which also takes a task that failed or waits on the user. */
     private prepareStart;
+    /** Why the work this task builds on keeps a start of it, a fresh one or a continue, from running now; null when it does not. */
+    private heldBehind;
     /**
      * The user's force start goes past what the scheduler waits for, so only
      * what no start could get past is refused here; the start rule decides the
@@ -3745,6 +4610,13 @@ declare class ExecutionCommands {
     private overriddenBy;
     private prepareMarkComplete;
     private prepareMarkNotDone;
+    /**
+     * A revert asks nothing of the run, so unlike an override it waits for no
+     * task that does not depend on the work (ADR-0054). What only git can say —
+     * that it is in the user's branch, that it conflicts — it says as it runs,
+     * in its turn on the queue.
+     */
+    private prepareRevert;
     private prepareInterrupt;
     private prepareCancelResume;
     private prepareCheckpoint;
@@ -3756,6 +4628,8 @@ declare class ExecutionCommands {
      */
     private prepareResume;
     private prepareStop;
+    /** What a refused Stop of a conflicted task can do instead: nothing runs it, so there is something else to press. */
+    private conflictNext;
     private prepareStopRun;
     private prepareMessage;
     /** A message queued behind the running turn, sent now or taken back; one delivered meanwhile is past either. */
@@ -3774,9 +4648,11 @@ declare class ExecutionCommands {
      */
     private skippedRefusal;
     /**
-     * Why a loop's check between rounds is not started from the seam: its loop
-     * runs it again itself, once its body has landed (ADR-0045 L5). Null for
-     * any other task.
+     * Why a loop's check between rounds is not started from the seam: something
+     * will run it, once its body has landed, or nothing will and its body has
+     * yet to land (ADR-0045 L5). Each says only what is true of it. Null for any
+     * other task, and for a check whose fix has landed that nothing else will
+     * run, which a start runs as its next round rather than leave it stranded.
      */
     private betweenRounds;
     /**
@@ -3956,12 +4832,26 @@ 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). */
     handles?(): ReadonlyMap<string, string>;
     /** A further refusal of what the change leaves: the supervisor's oscillation guard (ADR-0029). */
     guard?(before: readonly Task[], after: readonly Task[]): string | undefined;
+    /** The node, below the root: a child's change is held to its mandate, where a commit would otherwise approve with no command (ADR-0056 M6). Absent, or undefined, at the root. */
+    child?(): NodeAuthority | undefined;
 }
 /** What a whole plan's JSON is held to as it is submitted. */
 interface PlanIntake {
@@ -3994,10 +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,
@@ -4086,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).
@@ -4112,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;
@@ -4132,6 +5056,7 @@ declare class CliAgentAiService implements IAiService {
     nativeSessionId(): string | null;
     /** The compactions the agents reported of their own context, never a subagent's or another thread's: their adapters drop those (ADR-0012 T10). */
     compactions(): number;
+    promptCacheTtlMs(): number | undefined;
     heldSecrets(): readonly string[];
     restart(): void;
     reset(): void;
@@ -4304,7 +5229,17 @@ interface LandedHistory {
  */
 interface PlannerToolsOffer {
     sessionId: string;
+    /** 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).
@@ -4345,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
@@ -4501,6 +5440,8 @@ interface IAiService {
      * T10). Absent where nothing compacts a context in place.
      */
     compactions?(): number;
+    /** How long this planner's prompt cache lasts, as its connector states it; absent when it states none (ADR-0057 R4). */
+    promptCacheTtlMs?(): number | undefined;
     /**
      * Optional: what automatic compaction does for the planner's model now
      * (ADR-0002) — on, off in the settings file, or off for want of a known
@@ -4684,6 +5625,14 @@ declare class PlannerTurn {
 }
 /** What a planner turn may change: the whole plan, or tasks through edits. */
 type PlanChange = 'plan' | 'edit';
+/** A wake-up turn's brief, as `PlannerBriefing` sends it: whole to a context that does not hold it, else a line on a change (ADR-0057 R5). */
+interface WakeBrief {
+    /** Which brief this is: a level's, or a report turn's. */
+    key: string;
+    whole: string;
+    /** All a context holding {@link whole} needs told, and all that may differ between two wake-ups of one brief. */
+    line: string;
+}
 /**
  * A wake-up turn (ADR-0029): a supervisor's turn on wake-up digests alone, no
  * user message in it. What it may do is its level's, decided by the host.
@@ -4698,7 +5647,7 @@ interface WakeUpTurn {
      */
     refused(change: PlanChange): string | undefined;
     /** Told to the model after the digests and never saved, like the plan block: who it is in this turn, and what it may do. */
-    brief?: string;
+    brief?: WakeBrief;
     /**
      * Who the turn acts for at the command seam, read at each call; absent, the
      * supervisor at the run's level. A turn on a report owed to the user's turn
@@ -4747,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. */
@@ -4789,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
@@ -4920,7 +5873,10 @@ 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;
     /**
      * What an API planner's chat condenses its context through during a turn
      * (ADR-0002): the open turn, the history that landed before it, and the
@@ -4929,12 +5885,24 @@ declare class PlannerConversation {
     private readonly compaction;
     constructor(host: PlannerConversationHost);
     get transcript(): readonly ConversationMessage[];
+    /**
+     * When the planner's prefix was last sent, as its provider counts a prompt
+     * cache's life: from the start of a request (ADR-0057 R4). The turn's opening
+     * stands for it: a turn's later calls keep the prefix warm for longer, so
+     * this can only say a wake is due earlier than it had to be. Null with no live
+     * context, whose next turn is a replay.
+     */
+    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.
      */
@@ -5314,7 +6282,12 @@ declare class PlannerConversation {
      * whole block or what changed (ADR-0012 T10).
      */
     private planView;
-    /** One line per task, subtasks indented under their parent, with stable references — null until the plan has tasks. */
+    /**
+     * One line per task, subtasks indented under their parent, with stable
+     * references — null until the plan has tasks. Past a size only the tasks a
+     * planner acts on get a line (`planWindow`); what a line waits for costs a
+     * start-rule walk, so the rest are not walked.
+     */
     private planRows;
 }
 
@@ -5377,93 +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;
-}
-
-/**
- * The bridge between "core needs an answer" and "a human somewhere is looking
- * at a UI". Core cannot prompt: the human may be at a browser, a TUI, a CLI
- * stream, or a VS Code webview, and on the web server they are on the far end
- * of a socket. So the Session parks a promise here, announces the request
- * through the normal broadcast seam, and every surface answers through the
- * same `resolve(id, granted)` call.
- *
- * Timeouts are load-bearing rather than defensive: a planner turn that blocks
- * forever on an unanswered prompt would hang the whole research loop with no
- * visible cause. On expiry the request resolves to denied and the model gets a
- * normal, actionable tool result. A task runner's request is the exception
- * (ADR-0018, A1): the runner is parked on it rather than a research loop, and
- * it waits for a person — or the supervisor — however long that takes.
- */
-interface PendingApproval {
-    id: string;
-    request: ApprovalRequest;
-    createdAt: string;
-}
-interface PendingApprovalsOptions {
-    /** Denies and resolves after this long with no answer. Default 5 minutes. */
-    timeoutMs?: number;
-    /** Announce a new request to the surfaces. */
-    onRequest?: (pending: PendingApproval) => void;
-    /** Announce that a request is no longer actionable (answered or expired). */
-    onSettled?: (id: string, granted: boolean, settled: {
-        request: ApprovalRequest;
-        decision: ApprovalDecision;
-    }) => void;
-}
-interface AskOptions {
-    /**
-     * An id the caller already announced the request under. One still in use is
-     * refused — denied at once — rather than overwriting the request that has it.
-     */
-    id?: string;
-    /** Wait for an answer however long it takes. */
-    noTimeout?: boolean;
-    /**
-     * Given the answer as the request settles, before anything awaiting the
-     * promise runs: a caller about to tear down what asked (a runner being
-     * stopped) must deliver the answer before it goes.
-     */
-    onDecision?: (decision: ApprovalDecision) => void;
-}
-declare class PendingApprovals {
-    private readonly opts;
-    private readonly entries;
-    private readonly listeners;
-    constructor(opts?: PendingApprovalsOptions);
-    /** Hear each new request once it is announced — the supervisor wakes on a runner's (ADR-0029). */
-    listen(listener: (pending: PendingApproval) => void): () => void;
-    /** Park a request and return the promise the approval policy awaits. */
-    ask(request: ApprovalRequest, options?: AskOptions): Promise<boolean>;
-    /** Park a request whose answer is more than yes or no. */
-    decide(request: ApprovalRequest, options?: AskOptions): Promise<ApprovalDecision>;
-    /**
-     * Answer one request. Returns false when the id is unknown or already
-     * settled. "Allow for this task" on a request that did not offer it is a
-     * plain allow: no grant is made that the requester never proposed.
-     */
-    resolve(id: string, answer: ApprovalAnswer): boolean;
-    /** Everything still awaiting an answer — replayed to a surface that connects late. */
-    outstanding(): PendingApproval[];
-    /**
-     * Deny everything in flight, or only the requests `which` picks. Called on
-     * abort and on session reset.
-     */
-    clear(which?: (request: ApprovalRequest) => boolean, note?: string): void;
-}
-
 /** 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. */
@@ -5525,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;
 
@@ -5598,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 {
@@ -5722,6 +6614,11 @@ interface GlobalRunSettings {
     supervisorRetryLimit: number;
     /** Reads a wake-up turn may make, in place of a user message's caps. */
     wakeUpReadBudget: number;
+    /**
+     * The token budget of a delegation tree (ADR-0055 D21, ADR-0056 M5); 0 is
+     * delegation off. One value, so delegation is never on with no budget.
+     */
+    delegationTokens: number;
 }
 declare const RUN_SETTINGS_DEFAULTS: Readonly<GlobalRunSettings>;
 declare class RunSettingsError extends Error {
@@ -5747,12 +6644,26 @@ interface UserSettings {
     autorun?: boolean;
     supervisorRetryLimit?: number;
     wakeUpReadBudget?: number;
+    delegationTokens?: number;
     /**
      * Whether an API planner prunes its own context ahead of a call that would
      * pass 90% of its model's window. Absent means on. Set in the file only:
      * no surface offers it.
      */
     plannerAutoCompaction?: boolean;
+    /**
+     * What a task runner loads of the user's own setup: all of it (`user`) or
+     * what a task needs (`minimal`). Absent means `user`. Set in the file only:
+     * 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
@@ -5953,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. */
@@ -5997,6 +6910,24 @@ interface ExecuteCommandResponse {
     message: string;
     payload?: CommandPayload;
 }
+/**
+ * `GET /api/plans/:id/escalations`: what waits on a person now (ADR-0053). A
+ * client holding a socket has the same list on every status update.
+ */
+interface EscalationsResponse {
+    escalations: Escalation[];
+}
+/**
+ * The body of `POST /api/plans/:id/escalations/answer`, run as the user, and
+ * answered as `execute-command` answers. `confirmed` is the user's yes to the
+ * option's `confirm`.
+ */
+interface AnswerEscalationRequest {
+    id: string;
+    option: string;
+    note?: string;
+    confirmed?: boolean;
+}
 /**
  * A plan as the planner routes return it: the session's plan state, not the
  * `SerializedPlan` a websocket `plan_generated` carries. The two differ —
@@ -6057,6 +6988,8 @@ interface MergeGateEntry {
 interface MergeGateResponse {
     mergeGate: MergeGateEntry[];
 }
+/** A revert that would not go ahead is an answer, not a failure, so it comes back 200 with why (ADR-0054). */
+type TaskRevertPreviewResponse = TaskRevertPreview;
 interface IsolationDiffResponse {
     diff: string;
 }
@@ -6582,6 +7515,8 @@ interface TaskLogView extends BlockList {
     readonly queued: readonly QueuedTaskMessage[];
     /** A turn is running. */
     readonly working: boolean;
+    /** When the open turn began (ISO), for a surface to count from; absent between turns and for a log saved before it was kept (#81). */
+    readonly turnStartedAt?: string;
     /** How the last turn ended; absent before the first one does. */
     readonly lastTurnEnd?: StructuredTurnEnd;
     /** What the runner reported over the attempt, subagents included. */
@@ -6608,6 +7543,70 @@ declare function reduceTaskLog(view: TaskLogView, event: TaskLogEvent): TaskLogV
 /** A whole attempt's events, folded from the start — what a reload shows. */
 declare function replayTaskLog(events: readonly TaskLogEvent[], from?: TaskLogView): TaskLogView;
 
+/** What the label reads: a `TaskLogView`'s blocks, which is all a webview holds of one. */
+type LoggedBlocks = {
+    readonly blocks: readonly DisplayBlock[];
+    readonly turnStartedAt?: string;
+};
+/** What {@link taskActivity} reads of a log: the view's turn flag, and whether the log is an attempt the runner is no longer in. */
+type LoggedTurn = LoggedBlocks & {
+    /** A turn is open in the log, as its `turn_start` said; a log that streams without one has open blocks but this unset. Absent where a surface holds no such flag, which reads as open. */
+    readonly working?: boolean;
+    /** How the last turn ended, as the view says; set means the log has seen a turn end, so what it left open is not a turn. */
+    readonly lastTurnEnd?: StructuredTurnEnd;
+    /** The log is an earlier attempt, browsed: whatever it left open ended with it. */
+    readonly archived?: boolean;
+};
+/**
+ * What a task's runner is busy with, from its log: the latest block still
+ * open decides, since that is what the runner is doing now. Several running
+ * subagents are counted rather than named, as no one of them is the task's
+ * latest work. The label holds runner output — a surface sanitizes it.
+ */
+declare function activityLabel(view: LoggedBlocks): string;
+/** The line above a composer: `busy` animates, and a quiet task's does not. */
+interface TaskActivity {
+    label: string;
+    busy: boolean;
+    /** When the open turn began (ISO): a surface counts from it on its own ticks (#81). Absent for a log saved before turns were dated. */
+    since?: string;
+}
+/**
+ * The activity line of an open task log, or null when it has none to show: a
+ * task not running, and one waiting on a runner request, whose card in the log
+ * already asks the user. A running task whose runner has gone quiet is named
+ * as the plan pane names it and is never `busy`, so a runner that is not
+ * producing anything cannot look as if it were. Nor can a runner between
+ * turns: `busy` needs an open turn, a running subagent that outlived it, or,
+ * in a log that has seen no turn end, a block still open (a stream whose
+ * `turn_start` this view never saw).
+ * A browsed earlier attempt has no line, whatever its log was left open on.
+ * A script task has no exception here, on any surface: it runs no model, but
+ * its log is what it printed, so a step still open is one running.
+ */
+declare function taskActivity(view: LoggedTurn, task: {
+    status: string;
+    idleSince?: string | null;
+    awaitingApproval?: number;
+}): TaskActivity | null;
+
+/**
+ * How long something has run, for an activity line: whole seconds (`42s`),
+ * then minutes and zero-padded seconds (`3m 05s`), then from an hour hours and
+ * zero-padded minutes (`1h 05m`), since seconds mean nothing by then. A
+ * fraction of a unit is dropped, not rounded up, so a time never reads ahead
+ * of the clock. Returns '' for a negative or non-finite input: a start time
+ * ahead of the reader's clock (skew between hosts) is not a duration to show.
+ */
+declare function formatElapsed(ms: number): string;
+/**
+ * The time from `startedAt` (ISO) to `now` (epoch ms), formatted. The clock is
+ * the caller's, so a surface counts on a tick it already draws and a test
+ * fixes it. '' when there is nothing to show: no start (a log saved before
+ * turns were dated) or one that cannot be read.
+ */
+declare function elapsedSince(startedAt: string | undefined, now: number): string;
+
 /**
  * The one-line head of a command row, shared by every surface: the tool's name
  * and the argument that says what the call is about.
@@ -6717,6 +7716,8 @@ declare function aheadOfDraft(text: string, draft: string): string;
 interface TurnGate {
     readonly open: string | null;
     readonly stopped: string | null;
+    /** When the open turn began (ISO), for its elapsed time (#81); absent when none is open or its daemon did not say. */
+    readonly openedAt?: string;
 }
 declare const NO_TURN: TurnGate;
 interface GatedConversation {
@@ -6735,6 +7736,13 @@ declare function followTurn(view: ConversationView, gate: TurnGate, input: Conve
  * turn's late output never lands. Nothing changes when no turn is open.
  */
 declare function stopTurn(view: ConversationView, gate: TurnGate): GatedConversation;
+/**
+ * The turn is over without its `planner_turn_ended` having been heard: its
+ * call failed or returned the plan. The open turn and its start go, so the
+ * next turn does not count from this one's; a stop still standing stays, as
+ * the stopped turn's stragglers have not stopped.
+ */
+declare function closeTurn(gate: TurnGate): TurnGate;
 
 /**
  * Whether the conversation holds anything the collapsed view hides — thinking,
@@ -6859,11 +7867,15 @@ declare function taskStatusKind(task: {
     status: string;
     idleSince?: string | null;
 }): TaskStatusKind;
+/** The word for a running task whose runner has printed nothing for a while (`quiet`). */
+declare const STALLED_LABEL = "Stalled";
 /** What an awaiting_user task waits on (ADR-0018, W1); null when no reason was saved. */
 declare function awaitingLabel(task: {
     status: string;
     awaitingReason?: AwaitingReason;
 }): string | null;
+/** A conflict repair that will start by itself (ADR-0015): progress, in words that ask nothing of the user. */
+declare function repairWaitLabel(wait: RepairWait): string;
 /** "Blocked by #1, #2.1": the failed tasks a blocked task waits on, by reference (ADR-0034). */
 declare function blockedByLabel(refs: readonly string[]): string;
 /** "On hold: could not connect to Ordewell's tools; start it again": why a task is out of the scheduler. */
@@ -6974,6 +7986,8 @@ interface ActionSubject {
     resumeAt?: string | null;
     /** Its last attempt left a runner session to continue (ADR-0018, K1). */
     continuable?: boolean;
+    /** A conflict repair of it will start by itself, which Stop withdraws (ADR-0015). */
+    repairWaits?: unknown;
 }
 /** The actions a task's row offers while a plan runs, in the order they are laid out. */
 declare function taskRowActions(task: ActionSubject, placement?: TaskRowPlacement): TaskRowAction[];
@@ -7014,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
@@ -7102,8 +8158,13 @@ interface TaskRowSubject {
         outcome: string;
         reported?: string;
     } | null;
+    /** Between rounds with nothing to run it: only the run knows that, so it is told (ADR-0045 L5). */
+    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;
@@ -7115,6 +8176,11 @@ interface TaskRowIsolation {
         limit: number;
     };
     repairedFiles?: string[];
+    /** Core's word that its landing can be reverted (ADR-0054); a surface offers the action only then. */
+    revertible?: true;
+    repairWaits?: RepairWait;
+    /** The task added to resolve its conflict, by id. */
+    resolver?: string;
 }
 /**
  * The plan a row labels its references against: the tree, so a subtask's
@@ -7160,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;
@@ -7202,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;
@@ -7237,10 +8305,16 @@ interface TaskRowView {
     autonomous: boolean;
     /** The repos its isolated work changed, by path; empty for a group of one. */
     repos: string[];
-    /** Integration stopped on a conflict: the one isolation state that needs the user. */
+    /** Integration stopped on a conflict: the one isolation state that needs the user. `resolver` is the task, by reference, that has it; then a second is not offered. */
     conflict: {
         repo: string | null;
         files: string | null;
+        resolver: string | null;
+    } | null;
+    /** A conflict repair that starts by itself once what it waits for clears (ADR-0015): `label` says what, in sentence case. Progress, so `conflict` is null. */
+    repairWaiting: {
+        label: string;
+        files: string | null;
     } | null;
     /** A conflict repair in flight (ADR-0015) — progress, not a blocker. */
     repairing: {
@@ -7273,6 +8347,8 @@ interface TaskRowView {
     dependencies: string[];
     /** What the row offers while a plan runs. */
     actions: TaskRowAction[];
+    /** Its landed work can be reverted before Merge all (ADR-0054): a surface offers Revert only then, and core's preview says the rest. */
+    revertible: boolean;
     /** The one mark its toggle sets. */
     mark: 'complete' | 'uncomplete';
     opsEditable: boolean;
@@ -7309,6 +8385,7 @@ declare function loopRowParts(loop: TaskRowLoop): string[];
  */
 interface TaskLogHeaderTask {
     status: string;
+    type?: string;
     awaitingReason?: AwaitingReason;
     skipReason?: string;
     resumeAt?: string | null;
@@ -7316,6 +8393,8 @@ interface TaskLogHeaderTask {
     idleSince?: string | null;
     /** Its last attempt left a runner session the task's composer can continue (ADR-0018, K1). */
     continuable?: boolean;
+    /** A conflict repair of it starts by itself once this clears (ADR-0015). */
+    repairWaits?: RepairWait;
     attemptUsage?: readonly AttemptUsage[];
 }
 /**
@@ -7353,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;
 /**
@@ -7404,6 +8483,21 @@ type OverrideDirection = 'complete' | 'uncomplete';
  * completion, never the work or what already ran on it.
  */
 declare function manualOverrideConfirmation(direction: OverrideDirection, label: string): string;
+/** What a revert does (ADR-0054), told with the list of tasks it takes: the same words on every surface. */
+declare const revertEffect = "Its landed work comes off the integration branch, newest first, and each task listed is held as not started until you retry it. Nothing in your own branch changes.";
+/** How a revert's confirmation calls a task: a subtask's order alone would name a top-level task. */
+declare function revertTaskRef(task: {
+    order: number;
+    ref?: string;
+}): string;
+/** One task of a revert's confirmation: `dependent` is one that goes with the task the user chose. */
+declare function revertListLine(task: {
+    order: number;
+    ref?: string;
+    title: string;
+    repos: readonly string[];
+    dependent: boolean;
+}): string;
 /** Why a manual override waits for the run to stop (ADR-0029); `label` names the task. */
 declare function manualOverrideStopFirst(direction: OverrideDirection, label: string): string;
 interface NewTaskFields {
@@ -7433,11 +8527,18 @@ declare const automergeSummary: (run: GlobalRunSettings) => string;
 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, 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, the planner may also start tasks it adds later.";
+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). 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. */
+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 DiffRowKind as $, ACT_RISK as A, type BlockingSubject as B, CHAT_COMMANDS as C, type CommandBlock as D, type CommandDescriptor as E, type CommandOutcome as F, type CommandPayload as G, type CommandStatus as H, type CommandsResponse as I, type CompactionBlock as J, type CompactionStatus as K, type Consent as L, type ContextCondenseRequest as M, ConversationBusyError as N, type ConversationCompactResponse as O, type ConversationCompaction as P, ConversationEditError as Q, type ConversationForkResponse as R, type ConversationInput as S, type ConversationRequest as T, type ConversationRewindResponse as U, type ConversationTurn as V, type ConversationView as W, DEFAULT_WEB_READ_BUDGET as X, type DaemonErrorCode as Y, type DecideOptions as Z, type DiffRow as _, AUTORUN_RISK as a, type PendingApproval as a$, type DiffStat as a0, type DisplayBlock as a1, EMPTY_CONVERSATION as a2, EMPTY_HOLD as a3, EMPTY_RUN as a4, EMPTY_TASK_LOG as a5, EMPTY_TASK_LOG_FOLLOW as a6, type ErrorBody as a7, type ExecuteCommandResponse as a8, type ExecuteResponse as a9, type LiveTail as aA, type LiveTailOptions as aB, type LocalEntry as aC, type LoopCheckFacts as aD, type LoopCheckState as aE, type LoopGuard as aF, type MappedTool as aG, type MarkdownToken as aH, type MergeGateEntry as aI, type MergeGateResponse as aJ, type MergeWordingHandoff as aK, type MessageBlock as aL, type MessageRole as aM, type ModelsResponse as aN, NOT_STARTED as aO, NO_TURN as aP, type NewTaskFields as aQ, type NotificationAction as aR, OUTPUT_LINES_DEFAULT as aS, OUTPUT_LINES_MAX as aT, type OkResponse as aU, type OpRef as aV, type OpRefusal as aW, type OrchestratorObserver as aX, type OutputPreview as aY, type OverrideDirection as aZ, PLANNED_WITH_LABEL as a_, type ExecutionCommand as aa, ExecutionCommands as ab, type ExecutionHost as ac, type ExecutionSummary as ad, type GatedConversation as ae, type GeneratePlanResponse as af, type GlobalRunSettings as ag, HEADLESS_CLI_COMMANDS as ah, type HandoffBlock as ai, type HandoffForkRepo as aj, type HandoffPeekSubject as ak, type IAiService as al, IDLE_ACTIVITY as am, type INotification as an, type IWebFetcher as ao, type IsolationDiffResponse as ap, type IsolationMergeResponse as aq, type IsolationPreviewNotice as ar, type IsolationPreviewResponse as as, IsolationRunController as at, LEASE_HEARTBEAT_MS as au, LEASE_STALE_MS as av, LeaseHost as aw, type LeaseHostKind as ax, type LeaseHostOptions as ay, type LiveOutputLookup as az, type AccountLimitBucket as b, type SessionData as b$, PendingApprovals as b0, type PendingApprovalsOptions as b1, type PlanBlock as b2, type PlanBlocks as b3, type PlanIntake as b4, type PlanMarkerStatus as b5, type PlanResponse as b6, type PlanSnapshot as b7, PlanStore as b8, type PlannerCommandSyntax as b9, type RewindTarget as bA, type RewindTargetsResponse as bB, type RunActivity as bC, type RunInput as bD, type RunMergeView as bE, RunSettingsError as bF, type RunSnapshotFrame as bG, type RunTask as bH, type RunTaskStatus as bI, type RunView as bJ, type RunnerAuth as bK, type RunnerAuthExec as bL, type RunnerAuthExecOptions as bM, type RunnerAuthExecResult as bN, type RunnerCatalog as bO, type RunnerLoadedBlock as bP, type RunnersResponse as bQ, STOPPED_BEFORE_START as bR, SUPERVISOR_LEVELS as bS, SUPERVISOR_LEVEL_LABEL as bT, type SerializedConversationMessage as bU, type SerializedPendingTurn as bV, type SerializedPlan as bW, type SerializedTask as bX, type SerializedTaskStatus as bY, type ServerInfoResponse as bZ, type SessionBroadcaster as b_, type PlannerContextDeps as ba, type PlannerContextStatus as bb, PlannerConversation as bc, type PlannerConversationHost as bd, type PlannerModelCandidate as be, type PlannerModelChoice as bf, PlannerModelMemory as bg, type PlannerModelRecall as bh, type PlannerModelStore as bi, type PlannerModes as bj, type PlannerNotReady as bk, PlannerNotReadyError as bl, type PlannerReadinessConfig as bm, type PlannerSubmission as bn, PlannerTurnDiscardedError as bo, PlannerTurnStoppedError as bp, PlannerUsageLimitError as bq, type PrdResponse as br, type PromptHold as bs, REPORT_PREVIEW_LINES as bt, RUN_SETTINGS_DEFAULTS as bu, type ReadRunnerAuthOptions as bv, type RefTask as bw, ResearchTasks as bx, type ResolveAll as by, type ResolveConflictResponse as bz, type AccountLimitSnapshot as c, type TaskRowPlacement as c$, type SessionFrame as c0, type SessionHeld as c1, SessionHeldError as c2, type SessionLease as c3, type SessionLeaseRecord as c4, type SessionListResponse as c5, type SessionMessage as c6, type SessionMeta as c7, type SessionNotice as c8, type SessionResponse as c9, type TaskLogBatch as cA, type TaskLogEvent as cB, type TaskLogFollow as cC, type TaskLogFollowInput as cD, type TaskLogHeaderKind as cE, type TaskLogHeaderTask as cF, type TaskLogHeaderUsage as cG, type TaskLogHeaderView as cH, type TaskLogResponse as cI, type TaskLogView as cJ, type TaskMessageResponse as cK, type TaskOp as cL, TaskOrchestrator as cM, type TaskOrchestratorDeps as cN, type TaskOrchestratorOptions as cO, type TaskOutputSource as cP, type TaskPlacement as cQ, type TaskQuery as cR, type TaskQueryCatalog as cS, type TaskQueryField as cT, type TaskRef as cU, type TaskRowAction as cV, type TaskRowContext as cW, type TaskRowHandoff as cX, type TaskRowIsolation as cY, type TaskRowKind as cZ, type TaskRowLoop as c_, type SettingsResponse as ca, SettingsService as cb, type SettingsUpdateResponse as cc, type SkillInvocation as cd, type SkillLoadBlock as ce, type SkillToken as cf, type StartAdmission as cg, type StopResponse as ch, type StreamStamp as ci, type SubagentBlock as cj, type SubagentChild as ck, type SubagentStatus as cl, type SupervisorPolicy 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 TaskAttemptSnapshot as cy, type TaskLogAttemptsResponse as cz, type AccountLimitStatus as d, describeMergeResult as d$, type TaskRowSubject as d0, type TaskRowUsage as d1, type TaskRowView as d2, type TaskRunFacts as d3, type TaskStatusKind as d4, type ThinkingDisplayBlock as d5, type ToolBlock as d6, type ToolHeadline as d7, type ToolStatus as d8, type TreeTask as d9, assignmentIssueText as dA, attachingLabel as dB, automergeSummary as dC, autorunSummary as dD, awaitingLabel as dE, blockNotice as dF, blockNotices as dG, blockedByLabel as dH, blockingFailures as dI, canMergeTasks as dJ, canSetDependencies as dK, canSplitTask as dL, capConflictFiles as dM, cardEditNeedsUnstarted as dN, cardEditable as dO, checkoutRule as dP, classifyOutcome as dQ, coalesceTaskLog as dR, compactionText as dS, confirmedOverride as dT, createAiService as dU, dependencyCandidates as dV, dependentsNotice as dW, dependentsOf as dX, describeHeld as dY, describeHolder as dZ, describeIsolationPreview as d_, TurnBudgets as da, type TurnGate as db, type UsageBlock as dc, type UserSettings as dd, WAITS_FOR_APPROVAL_LABEL as de, type WakeUpItem as df, type WebRead as dg, type WebReadDecision as dh, type WebReadOptions as di, WebReadPolicy as dj, type Worded as dk, type WorkspacesResponse as dl, abbreviateHome as dm, accountLimitPercentText as dn, accountLimitWindowLabel as dp, accountLimitsOf as dq, accountLimitsText as dr, accountLimitsTitle as ds, aheadOfDraft as dt, applyTaskOps as du, approvalKindText as dv, approvalLabel as dw, approvalStatusText as dx, assignedRunnerOf as dy, assignmentIssue as dz, type AccountLimitWindow as e, ranSealed as e$, describePlannerNotReady as e0, diffRows as e1, diffStat as e2, diffSummary as e3, digestTaskLog as e4, drainNext as e5, editableWhileRunning as e6, executionSummary as e7, followTaskLog as e8, followTurn as e9, mapAgentTool as eA, markAction as eB, markdownHtml as eC, markdownTokens as eD, mergeOutcome as eE, mergeTarget as eF, namedRepos as eG, newTaskFields as eH, noExecutorRefusal as eI, normalizeAgentArgs as eJ, opRefusalText as eK, opsEditable as eL, outputLines as eM, outputPreview as eN, overrideNeedsConfirmation as eO, parseCount as eP, parseSwitch as eQ, parseTaskOpsJson as eR, parseTaskQueryJson as eS, pastGateConfirmation as eT, planBlocks as eU, planMarkerParts as eV, plannerMessage as eW, plannerNotReady as eX, plannerNotReadyFor as eY, plannerTranscript as eZ, processLeaseHost as e_, fromTranscript as ea, getSettingsPath as eb, handoffBaseLine as ec, handoffBranchName as ed, handoffFindingsText as ee, handoffPeekParts as ef, hasAccountLimits as eg, hasHiddenDetail as eh, hasLongReport as ei, holdLabel as ej, holdPrompt as ek, isFileEditTool as el, isRepoGroup as em, isTaskRunning as en, lastServedModel as eo, loadedSkillTokens as ep, logContinues as eq, logResumes as er, loopBodyLabel as es, loopBodyRound as et, loopCheckLabel as eu, loopCheckState as ev, loopLeaveNotice as ew, loopRowParts as ex, manualOverrideConfirmation as ey, manualOverrideStopFirst as ez, type AccountLimitsFrame as f, truncateCheckpointSummary as f$, readRunnerAuth as f0, receiptLabel as f1, reconcileApprovals as f2, recordRunnerAuth as f3, recordedRunnerAuth as f4, reduceConversation as f5, reduceRun as f6, reduceTaskLog as f7, renderTaskQueryAnswer as f8, repairedLanded as f9, supervisorSummary as fA, surfacePlan as fB, surfacePlanState as fC, takeAt as fD, taskActionCommand as fE, taskChatAvailable as fF, taskLogCommands as fG, taskLogForSurface as fH, taskLogHeaderView as fI, taskOrderLabel as fJ, taskPlacement as fK, taskQuerySignature as fL, taskRef as fM, taskRefOf as fN, taskRowActions as fO, taskRowView as fP, taskStartedNotice as fQ, taskStatusKind as fR, textHasTaskOps as fS, textHasTaskQuery as fT, titledRefs as fU, titledTaskRef as fV, titledTaskRefOf as fW, toTaskLogEvent as fX, toolHeadline as fY, trailerSummary as fZ, trimToolOutput as f_, repairedNotice as fa, repeatingChecks as fb, replayTaskLog as fc, repoBaseLine as fd, repoResultLines as fe, reposWithWork as ff, resetRunnerAuth as fg, resolveSkillInvocation as fh, resolveTaskRef as fi, resolveUserTaskRef as fj, resumeLabel as fk, resumeTime as fl, runHoldsEditors as fm, runSettingsOf as fn, runnerToolSubject as fo, scriptExitText as fp, scriptRunText as fq, secondsText as fr, serializePlan as fs, serializeTask as ft, serializeTaskStatus as fu, skillTokens as fv, skippedLabel as fw, stopTurn as fx, subtreeIds as fy, summarizeToolCall as fz, type AccountLimitsMessage as g, unsendAll as g0, unsendLatest as g1, wakeUpItems as g2, walkPlan as g3, withoutSealedMark as g4, workspaceEnvOf as g5, type AdoptSessionResponse as h, type ApplyTaskOpsResult as i, type ApprovalAnswerResponse as j, type ApprovalBlock as k, type ApprovalRequestMessage as l, type ApprovalStatus as m, type ApprovalsResponse as n, type ApproveReviewResponse as o, type AskOptions as p, type AssignmentCatalog as q, type AssignmentIssue as r, type AssignmentScope as s, type AssignmentWriter as t, type AutoMergeTrigger as u, CHECKPOINT_TRUNCATE_LENGTH as v, type CancelPlanningResponse as w, type CancelResumeResponse as x, CliAgentAiService as y, type CliAgentAiServiceDeps 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 };