@ordewell/core 0.11.3 → 0.12.1

package/dist/{Task-BL4Idm9r.d.ts → Task-CxGgN6I0.d.ts}

@@ -5,9 +5,14 @@ declare const SEVERITY_LABEL: Record<FindingSeverity, string>;
 declare function severityLabel(severity: FindingSeverity): string;
 /** The worst severity among `findings`, or null for none: what a compact row says at a glance. */
 declare function worstSeverity(findings: readonly Pick<HandoffFinding, 'severity'>[]): FindingSeverity | null;
+/** The root's plan: the node a pinned reference is under until a plan below names its own (ADR-0057 R1). */
+declare const ROOT_NODE = "root";
 /**
  * A typed reference a reader can check rather than trust. A `task` names the
  * task by id once the call is accepted, and `finding` one of its findings.
+ * `node` and `attempt` pin it (ADR-0057 R1): F numbers restart per attempt, so
+ * a finding is named only with the attempt it belongs to. One saved before
+ * pinning has neither, and reads the latest attempt as it always did.
  * `resolved` is read-time metadata: the author cannot vouch for resolution,
  * so the completion schema strips it and the saved handoff carries no check.
  */
@@ -21,14 +26,23 @@ type HandoffEvidence = {
     sha: string;
     repo?: string;
     resolved?: boolean;
-} | {
-    kind: 'task';
-    task: string;
-    finding?: string;
-} | {
+} | TaskEvidence | {
     kind: 'url';
     url: string;
 };
+/**
+ * `label` is how the task's own plan names it, kept once a reference has
+ * crossed a level: a reader in another plan has no plan to name it from, and a
+ * task id can repeat between plans, so no plan names one that has it.
+ */
+interface TaskEvidence {
+    kind: 'task';
+    node?: string;
+    task: string;
+    attempt?: number;
+    finding?: string;
+    label?: string;
+}
 /**
  * What a saved patch does not carry as the task's worktree held it
  * (ADR-0050): `excluded`, a symbolic link or a submodule, never carried;
@@ -85,6 +99,41 @@ interface HandoffCommit {
     subject: string;
     body?: string;
 }
+/** A finding as it crossed a level (ADR-0057 R2): its author's words, by the reference that names it. A subplanner's own has none. */
+interface ReportItem {
+    ref?: TaskEvidence;
+    finding: HandoffFinding;
+}
+/**
+ * What a delegated task's report carries past any task's (ADR-0057 R2). All of
+ * it comes from Ordewell, the findings by reference, so what a subplanner left
+ * out shows and it cannot have reworded what it passes on. It is read once, as
+ * the report is taken, so the renderer stays a pure function of the digest:
+ * references are pinned, so the words cannot have moved.
+ */
+interface SubtreeReport {
+    /** The child plan's node: what a read of this report's subtree starts from. */
+    node: string;
+    counts: {
+        done: number;
+        failed: number;
+        blocked: number;
+        skipped: number;
+        commits: number;
+        tokens: number;
+    };
+    /** Every finding below, by severity, read from the latest attempt of each task. */
+    findings: Record<FindingSeverity, number>;
+    /** What the parent must decide. */
+    open: ReportItem[];
+    /** What the subplanner passed up. */
+    promoted: ReportItem[];
+    /** What its branch changed outside its declared scope, first paths and how many (ADR-0056 M7). */
+    outsideScope?: {
+        paths: string[];
+        count: number;
+    };
+}
 /** What the plan keeps on a task: enough for a surface or a dependent's prompt without reading a log. */
 interface HandoffDigest {
     commit?: HandoffCommit;
@@ -93,6 +142,12 @@ interface HandoffDigest {
     findings: HandoffFinding[];
     findingCount: number;
     artifacts?: HandoffArtifact[];
+    /** The attempt it is from, which a reference to it is pinned to (ADR-0057 R1); absent on a plan saved before it was kept. */
+    attempt?: number;
+    /** A delegated task's: what Ordewell derived of its subtree. */
+    subtree?: SubtreeReport;
+    /** A delegated task's words with no {@link subtree} to say whose they are: a repair's, or a report that never opened a child. */
+    held?: true;
 }
 /** The whole handoff, as the attempt's log keeps it. */
 interface StoredHandoff extends HandoffDigest {
@@ -107,6 +162,7 @@ interface Handoff {
     findings?: Omit<HandoffFinding, 'id'>[];
     artifacts?: HandoffArtifact[];
     report?: string;
+    subtree?: SubtreeReport;
 }
 /** The most a report keeps: whole findings fit, and a runaway one does not bloat the files that hold it. */
 declare const REPORT_MAX_CHARS = 20000;
@@ -119,6 +175,7 @@ declare const HANDOFF_LIMITS: {
     readonly commitSubject: 100;
     readonly commitBody: 500;
     readonly findings: 50;
+    readonly promoted: 8;
     readonly title: 200;
     readonly detail: 2000;
     readonly reference: 2000;
@@ -144,7 +201,50 @@ declare function handoffDigest(handoff: StoredHandoff): HandoffDigest;
 type HandoffTaskName = (taskId: string) => string | undefined;
 /** A handoff with the tasks it cites named by their references in `plan`, as a reader names them. */
 declare function namedHandoff<H extends HandoffDigest>(plan: readonly Task[], handoff: H): H;
-/** A typed reference as a reader says it: `src/a.ts:42`, `commit abc`, `task #2 F1`, a URL, a saved patch. */
+/** A task reference as a reader writes it and an author may: `#4@2/F3`, `#4/F3`, `#4@2` or `#4` (ADR-0057 R1). */
+interface WrittenTaskRef {
+    task: string;
+    attempt?: number;
+    finding?: string;
+}
+/** The plan a written reference names below this one, `3/2:#4@2/F3`, and the rest as a plan reads it (ADR-0057 R1). */
+declare function parsePlanPath(written: string): {
+    path: string;
+    rest: string;
+} | undefined;
+/** A node's path as a reader writes it: `root/3/2` is `3/2`. */
+declare function nodeText(node: string): string;
+/**
+ * The parts of a written reference, its task as written. What this cuts off
+ * is no part of `TaskRefs`' grammar, which stays as it was; a caller tries the
+ * text whole first, since a title may end in anything.
+ */
+declare function parseFindingRef(written: string): WrittenTaskRef;
+/**
+ * A written reference resolved in a plan, its pin apart. The text is tried
+ * whole first: a title may end in anything, and a task it names stands as it
+ * always did. Undefined when it names no task there.
+ */
+declare function resolveWrittenRef(plan: readonly Task[], written: string): (Omit<WrittenTaskRef, 'task'> & {
+    task: Task;
+}) | undefined;
+/**
+ * The attempt of a removed task a reference naming no task in the plan reaches,
+ * by the id it renders with: a removed task keeps its log (ADR-0057 R1). The
+ * graph no longer reaches that task, so a citation does: a handoff in the
+ * reader's readable set must cite the attempt, since a task cannot read work it
+ * was never given (ADR-0047). A citation saved unpinned cites the latest, and a
+ * reference naming no attempt takes the newest one cited. `asked` is an attempt
+ * given apart from the text. Undefined when nothing it may read cites one.
+ */
+declare function removedAttempt(plan: readonly Task[], readable: ReadonlySet<string>, logs: HandoffLogs, written: string, asked?: number): {
+    taskId: string;
+    attempt: number;
+    finding?: string;
+} | undefined;
+/** The pinned reference as text: `#4@2/F3` (ADR-0057 R1); `task` is how the reader names it. */
+declare function findingRefText(task: string, ref: Pick<WrittenTaskRef, 'attempt' | 'finding'>): string;
+/** A typed reference as a reader says it: `src/a.ts:42`, `commit abc`, `#2@1/F1`, a URL, a saved patch. */
 declare function handoffReferenceText(ref: HandoffArtifact, taskName?: HandoffTaskName): string;
 /** A size as a reader takes it in: bytes, KB or MB. */
 declare function byteSize(bytes: number): string;
@@ -195,8 +295,20 @@ declare function savedPatchView(handoff: HandoffDigest | undefined): PatchView |
 declare function findingLines(f: HandoffFinding, taskName?: HandoffTaskName): string[];
 /** A handoff's artifacts as one line, or none when it lists none. */
 declare function artifactLines(handoff: HandoffDigest, taskName?: HandoffTaskName): string[];
+/** A delegated task's words as its parent's update holds them, every line indented, so none can pass for a line of Ordewell's (ADR-0057 R3). */
+declare function heldWords(text: string): string[];
+/** The same handoff, marked as a delegated task's where no report already says so: a mark that travels with it to whatever renders it. */
+declare function heldHandoff<H extends HandoffDigest>(task: {
+    type?: string;
+}, handoff: H): H;
 /** A handoff's opening as text: its commit, subject then body, then the summary. */
 declare function openingLines(handoff: HandoffDigest): string[];
+/**
+ * How another task's words are introduced wherever they cross into a prompt
+ * or a run update (ADR-0057 R3): whose they are, and that they are data. On
+ * every wake and every dependency, so it stays this short.
+ */
+declare function wordsFrom(what: string, whose: string): string;
 /** Each pushed handoff's text ceiling, excluding artifacts (ADR-0047). */
 declare const HANDOFF_PUSH_CHARS = 4000;
 /** Shared push rendering: reserve the closing pointer before accepting each whole finding. */
@@ -239,17 +351,56 @@ type HandoffCheck<H> = {
     ok: false;
     refusal: string;
 };
+/** What the session's saved logs say of a task's attempts, for a reference to be pinned against (ADR-0057 R1). */
+interface HandoffLogs {
+    /** The attempts of a task that have a saved log, oldest first. */
+    attempts(taskId: string): readonly number[];
+    /** The handoff one attempt ended with, if its log holds one. */
+    handoff(taskId: string, attempt: number): HandoffDigest | undefined;
+}
+interface HandoffPins {
+    /** The saved logs; without them a reference pins to what the plan's digest says, or stays unpinned. */
+    logs?: HandoffLogs;
+    /** The attempt making the call: what a task naming itself is pinned to. */
+    attempt?: number;
+    /** The plan these references are pinned under. Absent, the root's. */
+    node?: string;
+    /** What the producer may cite in `plan`, for one the plan's graph cannot give it: a subplanner, the plan below its own delegated task, is in none of its tasks' graphs. */
+    readable?: ReadonlySet<string>;
+    /** The plan at a path below this one that the producer may read; undefined for one it may not, or that is not there. */
+    below?: (path: string) => BelowPlan | undefined;
+    /** The handoff goes up a level, so what it cites keeps the name its plan gives it. */
+    crossing?: true;
+}
+/** A plan of the subtree, as a reference reads it. */
+interface BelowPlan {
+    node: string;
+    tasks: readonly Task[];
+    logs: HandoffLogs;
+}
+/**
+ * One written reference pinned, in the producer's plan or a plan below it:
+ * the text is tried whole first, since a title may read like a path.
+ */
+declare function pinReference(plan: readonly Task[], producerId: string, pins: HandoffPins, ref: TaskEvidence, field: string, findings: number, refuse: (why: string) => void): TaskEvidence | undefined;
 /**
  * Check the references a handoff makes, at the call (ADR-0047): a `task`
  * must be one the producer may read and a finding of it one that exists, and
  * a `url` must be http or https, so no surface renders a `javascript:` link.
  * A `file` or `commit` is a claim about a tree Ordewell may not see, so it is
  * taken as given. An accepted handoff names each task by its id, which a
- * later edit of the plan does not renumber.
- */
-declare function checkHandoff<H extends Handoff>(handoff: H, producerId: string, plan: readonly Task[]): HandoffCheck<H>;
+ * later edit of the plan does not renumber, and the attempt it read, so a
+ * retry or a loop round that numbers its findings anew leaves it meaning what
+ * it meant (ADR-0057 R1). A task with nothing to say its attempt by stays
+ * unpinned, and reads the latest, as a reference saved before pinning does. A
+ * removed task may be cited where a handoff the producer may read cites it, so
+ * what it read can be passed on ({@link removedAttempt}).
+ */
+declare function checkHandoff<H extends Handoff>(handoff: H, producerId: string, plan: readonly Task[], pins?: HandoffPins): HandoffCheck<H>;
 
 interface TaskDiffRead {
+    /** Only the changed paths, joined by NUL: what a verdict reads (ADR-0055 D6). */
+    names?: boolean;
     repo?: string;
     path?: string;
 }
@@ -403,6 +554,8 @@ interface IsolationTaskRecord {
     status: IsolationTaskStatus;
     /** Keyed by repo path. */
     repos: Record<string, IsolationTaskRepo>;
+    /** The child session whose code root this worktree is (ADR-0055 D11): what stops a prune taking it from under that child (D17). */
+    childSession?: string;
     /** Unrecovered branches from a conflict fallback, so a later continue cannot forget them. */
     continuationWork?: PreservedWork[];
     /** The repo whose merge stopped the task from landing, while `status` is `conflict` or `failed`. */
@@ -445,10 +598,12 @@ interface IsolationTaskRecord {
      */
     readOnly?: true;
     /**
-     * Set once the task's landed work is in the checked-out HEAD of every repo
-     * it changed — merged into the user's branch, by Merge all or by hand — or
-     * can no longer be merged there, its integration branch gone. What a merge
-     * gate waits for (ADR-0020).
+     * Set once the task's landed work is merged into the user's branch in every
+     * repo it landed in, by Merge all or by hand — never by a checkout that only
+     * stands on the integration branch (ADR-0054) — or can no longer be merged
+     * there, its integration branch gone. What a merge gate waits for (ADR-0020).
+     * Git's answer as last read, so it goes when the user takes the merge back
+     * out; it goes with the record too, so a revert asks git of each merge instead.
      */
     inHead?: true;
 }
@@ -462,6 +617,16 @@ interface IsolationLanding {
     taskId: string;
     /** Keyed by repo path. */
     tips: Record<string, string>;
+    /**
+     * Set when this is a revert rather than a landing (ADR-0054), by repo path:
+     * what a rollback has to find on that repo's tip to take it off again.
+     */
+    reverts?: Record<string, IsolationRepoRevert>;
+}
+/** A revert's share of one repo, saved so that it can tell its own commits from anyone else's. */
+interface IsolationRepoRevert {
+    /** The commits it has made, oldest first, each saved before the branch moves onto it. */
+    commits: string[];
 }
 /**
  * One repository of the group (ADR-0014). Every git operation on it runs in
@@ -491,7 +656,13 @@ interface IsolationRepo {
  */
 interface IsolationRun {
     id: string;
+    /** The code root: what git reads for the run's repos, branch and base (ADR-0055 D11). */
     workspaceRoot: string;
+    /**
+     * A child run's state root, the root Session's workspace: where its worktrees
+     * and Ordewell's own files go. Absent on a flat run, whose workspace is both.
+     */
+    stateRoot?: string;
     repos: IsolationRepo[];
     /**
      * Workspace paths outside every isolated repo, linked live into each task
@@ -511,6 +682,51 @@ interface IsolationRun {
      * names exactly what to return each repo's integration branch to.
      */
     landing?: IsolationLanding;
+    /**
+     * Every merge that landed a task, by task id and repo, oldest first. A
+     * continue or a retry lands a task again under a new record, so no record
+     * holds them all, and a revert takes them all back (ADR-0054). A run saved
+     * before these were kept has only each record's `landedTip`.
+     */
+    landings?: Record<string, Record<string, string[]>>;
+    /**
+     * Set on a run started with {@link landings} kept from its first merge. A
+     * run saved before that can hold merges no record names, so a revert cannot
+     * take the absence of a task's landings as proof it landed nothing.
+     */
+    keepsEveryLanding?: true;
+    /**
+     * Task branch tips another task's merge brought in, by task id and repo: a
+     * resolver's merge carrying a conflicted task's work. No merge of that task
+     * holds this work, and a later attempt's record says nothing of it, so
+     * neither task can be reverted (ADR-0054). A tip git could not say of when
+     * that merge landed is here too. Set on every run as it starts, empty
+     * included: a run without it is older, what its merges carried is unknown,
+     * and every revert of it is refused.
+     */
+    carried?: Record<string, Record<string, string[]>>;
+    /**
+     * What each task in {@link landings} or {@link carried} landed as: all a
+     * revert has to name it by once a retry has dropped its record and left its
+     * merges on the branch.
+     */
+    landedTasks?: Record<string, LandedTask>;
+    /**
+     * What each task depended on when its worktree was cut and when it landed,
+     * directly or not, by task id, across every attempt. A plan edit takes a link
+     * while a worktree stays cut from what it stood on, and leaving the plan takes
+     * a task's dependencies with it, and those of the tasks that named it, while
+     * its merges stay on the branch, so this is what finds a dependent the plan
+     * has lost, at work or landed. A landed task the plan no longer has and this
+     * does not name refuses every revert of the run (ADR-0054).
+     */
+    landedOn?: Record<string, string[]>;
+    /**
+     * A task's revert was committed on this run (ADR-0054): the integration
+     * branch holds commits no record names, so the run carries on even with no
+     * record left, and a retry starts from its tip.
+     */
+    reverted?: true;
 }
 /**
  * What a plan persists of isolated execution (`LegacyPlanState.isolation`): its
@@ -530,8 +746,13 @@ interface PlanIsolation {
  * that has an isolation run.
  */
 type TaskIsolationState = 'none' | 'active' | 'integrated' | 'conflict' | 'repairing' | 'kept';
-type TaskIsolation = {
+/** What a conflict repair that will start by itself waits for (ADR-0015). */
+type RepairWait = 'slot' | 'planner' | 'usage-limit';
+type TaskIsolation = 
+/** `revertible`: no record, but merges of an earlier attempt are still on the branch. */
+{
     state: 'none';
+    revertible?: true;
 } | {
     state: Exclude<TaskIsolationState, 'none'>;
     branch: string;
@@ -549,6 +770,12 @@ type TaskIsolation = {
     };
     /** What {@link IsolationTaskRecord.repairedFiles} says. */
     repairedFiles?: string[];
+    /** Its landing has a merge of its own and is not in the user's branch: what a surface offers a revert on (ADR-0054). */
+    revertible?: true;
+    /** A `conflict` whose repair starts by itself once this clears: progress, not a conflict to act on (ADR-0015). Said by the scheduler, not the record. */
+    repairWaits?: RepairWait;
+    /** A `conflict` a task was added to resolve, by id: its one worker (ADR-0015). */
+    resolver?: string;
 };
 interface IsolationLandedTask {
     taskId: string;
@@ -693,6 +920,87 @@ type PreviousWork = {
 };
 /** A task as a removal names it. */
 type IsolationTaskRef = Pick<IsolationTaskRecord, 'taskId' | 'order' | 'title'>;
+/** A task as its landings name it, and what the commit that reverts one is worded from. */
+type LandedTask = IsolationTaskRef & Pick<IsolationTaskRecord, 'commit'>;
+/** A task a revert acts on, with the repos its landing changed. */
+interface IsolationRevertTask extends IsolationTaskRef {
+    repos: string[];
+}
+/**
+ * What undoes a task's landing once something of the user's holds it: a command
+ * for them to run, which Ordewell shows and never runs (ADR-0054).
+ */
+interface RevertCommand {
+    task: IsolationTaskRef;
+    repo: string;
+    /** The task's merge commit, which `heldBy` holds. */
+    commit: string;
+    /** Ready to type at the workspace root. */
+    command: string;
+    /** What holds it and stops a revert: local branches by name, and 'HEAD' for a detached HEAD. */
+    heldBy: string[];
+    /** Whether the user's own branch is among them; if not, `heldBy` may be only a review. */
+    merged: boolean;
+}
+/**
+ * What git says of the landed work a revert would take, newest landing first.
+ * `inBranch`: the part something of the user's holds, which no revert touches;
+ * newest first too, the order to run the commands in. `no-own-merge`: a task's
+ * work came in through another's merge, a conflict resolver's, so no merge of
+ * its own can undo it. `git`: git could not read what the record names, or say
+ * what holds it.
+ */
+type LandedWork = {
+    ok: true;
+    tasks: IsolationRevertTask[];
+    inBranch: RevertCommand[];
+} | {
+    ok: false;
+    reason: 'no-own-merge' | 'checked-out' | 'git';
+    error: string;
+};
+/** What {@link IWorktreeIsolation.revert} asks of its caller, in its turn. */
+interface RevertWatch {
+    /** Why the revert may no longer go ahead, read once it has its turn and again with its commits made, which it then rolls back; null when it may. */
+    refusal: () => string | null;
+    /** Called once the tips are recorded and before the first commit, as a landing's `persist` is, and again as each commit is made. */
+    persist: () => void;
+    /** Called in the one synchronous step that lets the records go, so a save never sees them gone with the tasks not yet back. */
+    settled: (taskIds: readonly string[]) => void;
+}
+/**
+ * How a revert ended (ADR-0054). Anything but `reverted` left every integration
+ * branch where it was, except a `failed` that says so: tips git would not put
+ * back stay recorded on the run, which holds landings and Merge all off them.
+ *
+ * - `reverted`: `tasks`, newest landing first, in every repo each changed.
+ * - `in-branch`: something of the user's holds part of it: `commands` undo it there.
+ * - `refused`: {@link RevertWatch.refusal} said no, or git found work with no
+ *   merge of its own, or the integration branch checked out where a revert
+ *   cannot commit to it.
+ * - `conflict`: reverting `task` conflicted in `repo`, over `files`.
+ * - `failed`: git stopped it; `error` says on what.
+ */
+type IsolationRevertResult = {
+    outcome: 'reverted';
+    tasks: IsolationRevertTask[];
+} | {
+    outcome: 'in-branch';
+    commands: RevertCommand[];
+} | {
+    outcome: 'refused';
+    reason: string;
+} | {
+    outcome: 'conflict';
+    task: IsolationTaskRef;
+    repo: string;
+    files: string[];
+} | {
+    outcome: 'failed';
+    error: string;
+    task?: IsolationTaskRef;
+    repo?: string;
+};
 /**
  * Work a removal found that had not landed — edits never committed, or
  * commits only the task's branch carried — committed and kept on `branch`,
@@ -744,6 +1052,8 @@ interface IWorktreeIsolation {
      * each, and the config enabled; otherwise the reason it is not.
      */
     isActive(workspaceRoot: string): Promise<IsolationAvailability>;
+    /** What the git on this machine holds back, as the line the user is told; null when it does everything, or there is no git to speak of. */
+    gitShortfall(): Promise<string | null>;
     /**
      * Put the tracked changes of every dirty repo of the group on its git stash,
      * the user's way out of a `dirty` refusal. Untracked files stay: they never
@@ -753,9 +1063,11 @@ interface IWorktreeIsolation {
     /**
      * Mint a run: resolve each repo's base ref to a commit now, and share the
      * repos that cannot be isolated. Only meaningful after `isActive` said yes;
-     * throws when no repo of the group can be isolated after all.
+     * throws when no repo of the group can be isolated after all. `stateRoot`
+     * makes it a child's run (ADR-0055 D11), and it throws for a `workspaceRoot`
+     * that is not a task's workspace under that root (D12).
      */
-    startRun(workspaceRoot: string): Promise<IsolationRun>;
+    startRun(workspaceRoot: string, stateRoot?: string): Promise<IsolationRun>;
     /**
      * Create the task workspace — one worktree per isolated repo from its
      * integration tip, the shared paths linked in — and return the cwd to spawn
@@ -784,6 +1096,13 @@ interface IWorktreeIsolation {
      * else: a task that fails stays `repairing` until released.
      */
     verifyRepair(task: Task, run: IsolationRun): Promise<RepairEvidence>;
+    /**
+     * The paths a repair brings onto the integration tip, by their place in the
+     * workspace: `repairBase` to the branch where the landing changed a repo, and
+     * the task's tip to it where it did not, since a repair can still edit that
+     * repo. Read after {@link verifyRepair} commits, before `integrate` moves the tip.
+     */
+    repairPaths?(task: Task, run: IsolationRun): Promise<string[]>;
     /**
      * Land the task atomically across the repos it changed: commit each
      * worktree, then `git merge --no-ff` the task branch into each changed
@@ -806,6 +1125,22 @@ interface IWorktreeIsolation {
      * the runner made is never rewritten.
      */
     integrate(task: Task, run: IsolationRun, persist?: () => void, commit?: HandoffCommit): Promise<IsolationOutcome>;
+    /**
+     * What git says of the tasks' landed work now. Reads only and takes no turn:
+     * it answers a confirmation, and {@link revert} reads it all again in its own.
+     */
+    readLanded(run: IsolationRun, taskIds: readonly string[]): Promise<LandedWork>;
+    /**
+     * Revert the tasks' landings on the integration branches (ADR-0054): one
+     * revert commit per landing, newest first, in every repo each changed or in
+     * none. Takes its turn on the landing queue, so it never reads
+     * a branch mid-landing, judges what it is asked again there, and writes only
+     * to Ordewell's own branches. Each reverted task's record goes: its landing
+     * no longer counts for anything. A record of a later attempt that did not
+     * land stays for the worktree it holds, kept like a stopped one's. What
+     * stops it puts every tip back.
+     */
+    revert(run: IsolationRun, taskIds: readonly string[], watch: RevertWatch): Promise<IsolationRevertResult>;
     /**
      * `keep: false` removes the task's worktree, branch and record (retry, task
      * removal), keeping whatever had not landed on a branch first; a record
@@ -838,11 +1173,20 @@ interface IWorktreeIsolation {
     reviewDiff(run: IsolationRun): Promise<string>;
     taskDiff?(run: IsolationRun, taskId: string, options: TaskDiffRead): Promise<TaskDiffResult>;
     /**
-     * Mark the landed tasks whose work the checked-out HEAD now contains in
-     * every repo they changed (`git merge-base --is-ancestor`), and return their
-     * ids. A repo whose integration branch is gone counts as containing it: no
-     * Merge all could bring that work in. Only adds marks: a task found merged
-     * stays merged.
+     * The blob `file` holds on `branch`, relative to `root`, the workspace
+     * (ADR-0057 R9): null where it holds none, undefined where nothing can be read.
+     * Refs are shared across worktrees, so a child reads an ancestor's branch too.
+     * A branch gone with its merged run reads as what `root` has checked out, which
+     * is where it merged.
+     */
+    blobOn?(root: string, branch: string, file: string): Promise<string | null | undefined>;
+    /**
+     * Read each landed task's mark again from git: on where the user's branch
+     * contains its work in every repo it changed (`git merge-base --is-ancestor`),
+     * off where it no longer does. Returns the ids whose mark changed. A review
+     * checkout of the integration branch, detached or not, contains nothing
+     * merged (ADR-0054). A repo whose integration branch is gone counts as
+     * containing it: no Merge all could bring that work in.
      */
     findInHead(run: IsolationRun): Promise<string[]>;
     /**
@@ -884,6 +1228,7 @@ interface IWorktreeIsolation {
      * Never a branch of `run` itself, one a worktree has checked out, or any
      * branch of a run that still has a worktree — that run may be live in
      * another plan. Tries every repo, then throws naming those where git failed.
+     * A child's run sweeps nothing (ADR-0055 D11).
      */
     sweep(run: IsolationRun): Promise<void>;
 }
@@ -985,6 +1330,12 @@ declare function partedPromptUsage(parts: {
     cacheRead?: number;
     cacheWrite?: number;
 }): Pick<UsageRecord, 'inputTokens' | 'cachedInputTokens'>;
+/**
+ * What a budget counts (ADR-0056 M5), of a record or of totals alike: the same
+ * tokens a total holds, input and output. `cachedInputTokens` is a share of the
+ * input, so cache reads count, once.
+ */
+declare function spentTokens({ inputTokens, outputTokens }: Pick<UsageTotals, 'inputTokens' | 'outputTokens'>): number;
 declare function addUsage(totals: UsageTotals, record: UsageRecord): UsageTotals;
 /**
  * What the planner has consumed over a session (#49). `totals` includes every
@@ -1097,6 +1448,7 @@ interface PlanUsage {
 }
 declare function addUsageTotals(totals: UsageTotals, addition: UsageTotals): UsageTotals;
 interface UsageTask {
+    type?: string;
     attemptUsage?: readonly AttemptUsage[];
     subtasks?: readonly UsageTask[];
 }
@@ -1112,7 +1464,7 @@ interface TaskUsageSummary {
     attempts: number;
     contextFill?: ContextFill;
 }
-declare function taskUsageSummary(task: Pick<UsageTask, 'attemptUsage'>): TaskUsageSummary;
+declare function taskUsageSummary(task: Pick<UsageTask, 'attemptUsage' | 'type'>): TaskUsageSummary;
 /** `950`, `1.5k`, `61k`, `261k`, `1.2M`. */
 declare function formatTokenCount(n: number): string;
 /** Two decimals from 1 up and up to four below it: a call can cost a fraction of a cent, a session several dollars. */
@@ -1153,7 +1505,7 @@ type SupervisorLevel = 'off' | 'watch' | 'act';
 declare function isSupervisorLevel(value: unknown): value is SupervisorLevel;
 /**
  * Who asked the command seam for an action (ADR-0029): the user, a planner
- * turn the user started, or the supervisor at its level.
+ * turn the user started, the supervisor at its level, autorun, or a subplanner.
  */
 type ExecutionActor = {
     kind: 'user';
@@ -1163,15 +1515,23 @@ type ExecutionActor = {
     kind: 'supervisor';
     level: SupervisorLevel;
 }
-/** The user's standing instruction to start each plan the planner submits (ADR-0030). */
+/** The user's standing instruction to start each plan the planner submits (ADR-0030); `leavesFailed` is what failed in that reply, which it does not run again. */
  | {
     kind: 'autorun';
+    leavesFailed?: ReadonlySet<string>;
+}
+/** Every turn of a child plan's planner (ADR-0056 M6): no person is there, so its grants alone answer. `depth` is its level, the root being 0. */
+ | {
+    kind: 'subplanner';
+    depth: number;
 };
-type ExecutionCommandName = 'run_plan' | 'run_task' | 'stop_task' | 'stop_run' | 'retry_task' | 'message_task' | 'answer_approval' | 'merge_all' | 'skip_task' | 'force_start' | 'mark_complete' | 'mark_not_done' | 'interrupt_task' | 'force_send_queued' | 'remove_queued' | 'cancel_resume' | 'answer_checkpoint' | 'approve_review' | 'run_script';
+/** Whose authority an actor's work runs under: a child has no user, so a subplanner's is a supervisor's (ADR-0056 M6). */
+declare function actorAuthority(actor: ExecutionActor['kind']): TurnAuthority;
+type ExecutionCommandName = 'run_plan' | 'run_task' | 'stop_task' | 'stop_run' | 'retry_task' | 'message_task' | 'answer_approval' | 'merge_all' | 'skip_task' | 'force_start' | 'mark_complete' | 'mark_not_done' | 'revert_task' | 'interrupt_task' | 'force_send_queued' | 'remove_queued' | 'cancel_resume' | 'answer_checkpoint' | 'approve_review' | 'run_script';
 /**
  * How the user consented to the script a `run_script` call ran (ADR-0035):
  * on the approval card, by an effect allowlist rule (by name), by autorun in
- * Full, or by choosing Act for the supervisor.
+ * Full, by choosing Act for the supervisor, or by a subplanner's mandate.
  */
 type ScriptConsent = {
     by: 'card';
@@ -1182,6 +1542,8 @@ type ScriptConsent = {
     by: 'autorun';
 } | {
     by: 'act';
+} | {
+    by: 'mandate';
 };
 /**
  * Where a `run_script` call's task stood as the call answered, or as it ended
@@ -1320,6 +1682,349 @@ declare class SkillsService {
  */
 declare function createSkillsService(workspaceRoot?: string, workspaceRepos?: readonly string[]): SkillsService;
 
+/** A script task's time limit when it sets none. */
+declare const DEFAULT_SCRIPT_TIMEOUT_MS: number;
+/** What a script task runs, its time limit filled in. */
+type ScriptBody = 
+/** Argument vectors run in order with no shell, stopping at the first that fails. */
+{
+    commands: string[][];
+    timeoutMs: number;
+}
+/** One script, run by the research shell's interpreter. */
+ | {
+    script: string;
+    timeoutMs: number;
+};
+type BodyFields = Pick<Task, 'type' | 'commands' | 'script' | 'timeoutMs'>;
+/** The body a script task runs; null for any other task, or one whose body the plan's rules refuse. */
+declare function scriptBodyOf(task: BodyFields): ScriptBody | null;
+/**
+ * An argument vector as a reader would type it in a shell: a word is quoted
+ * only where it needs to be, and one holding a character a reader cannot see
+ * is written with escapes (`$'…'`), so a command is always one line and reads
+ * as what runs. For reading only; nothing runs it.
+ */
+declare function commandLine(argv: readonly string[]): string;
+/**
+ * A script task's body as the approval card shows it (ADR-0035), so the
+ * consent is to what will run: each command on a line of its own, or the
+ * script as written, then the time limit. A character a reader cannot see in
+ * a script, but for its line breaks and tabs, is shown as its code.
+ */
+declare function scriptBodyText(body: ScriptBody): string;
+/**
+ * A script task as a row shows it: the body {@link scriptBodyText} gives the
+ * approval card, so what the user read when consenting is what the plan lists.
+ * A task whose body the plan's rules refuse says so rather than showing nothing.
+ */
+declare function scriptTaskText(task: BodyFields): string;
+/** A time limit in the largest units it is a whole number of: "10 minutes", "90 seconds". */
+declare function timeLimitText(ms: number): string;
+
+/**
+ * The planner's standing approvals (ADR-0026): what runs without asking
+ * anyone, under every approval mode.
+ *
+ * One entry is one of:
+ *
+ *   - a **command rule**, `gh issue list` or `gcloud * * list`: the binary,
+ *     then words matched against the command's leading arguments, the ones
+ *     before its first flag. A command whose leading words match the rule's
+ *     runs, whatever arguments follow — but the rule must spell out at least
+ *     the words the command's approval scope holds (ADR-0008, T1), so
+ *     `az group` never covers `az group delete`, and a one-word read takes a
+ *     `*` for its argument (`kubectl get *`). `*` stands for one word, and
+ *     inside a word for any run of characters (`describe-*`). An entry equal
+ *     to a scope also matches that scope, as pre-approved scopes always did.
+ *   - an **MCP tool rule**, `mcp:find-*`: a glob over the tool's own name,
+ *     without the server, case-insensitive.
+ *   - a **scope pattern**, anything starting with `/`, `~`, `http://`,
+ *     `https://`, `web_search:`, `mcp__`, `mcp-server:` or a drive letter: matched against an approval's
+ *     scope as ADR-0008 always matched pre-approved entries, `*` matching any
+ *     run of characters.
+ *
+ * A leading `!` excludes instead, and an exclusion wins over every rule. A
+ * command exclusion's words are looked for anywhere among the arguments, in
+ * order, flags included and case ignored, so `!kubectl *secret*` and
+ * `!* --endpoint*` hold wherever the word appears; a lone short flag (`-s`)
+ * also holds inside a bundle (`-As`, `-shost`). `*` as its binary covers
+ * every command.
+ */
+/** The words a command rule is matched against: a lexed segment's binary and arguments. */
+interface CommandWords {
+    binary: string;
+    args: readonly string[];
+    /** How many leading arguments the command's approval scope holds; a rule must cover at least that many. */
+    scopeWords?: number;
+}
+interface RuleWord {
+    matches: (word: string) => boolean;
+    wildcard: boolean;
+}
+interface CommandRule {
+    text: string;
+    binary: string;
+    words: RuleWord[];
+}
+interface PlannerAllowlist {
+    commands: CommandRule[];
+    commandExclusions: CommandRule[];
+    tools: RegExp[];
+    toolExclusions: RegExp[];
+    scopes: RegExp[];
+    scopeExclusions: RegExp[];
+}
+declare function parseAllowlist(entries: readonly string[]): PlannerAllowlist;
+/** The rule that lets this command run unasked, or undefined when none does or an exclusion holds. */
+declare function commandAllowedBy(list: PlannerAllowlist, command: CommandWords): string | undefined;
+/** Whether an MCP tool, by its own name without the server, runs unasked. */
+declare function toolAllowed(list: PlannerAllowlist, tool: string): boolean;
+/** Whether an approval scope — a directory, an origin, a tool's full name — is pre-approved. */
+declare function scopeAllowed(list: PlannerAllowlist, scope: string): boolean;
+/**
+ * Read-only command families that are safe to run unasked: they read, never
+ * write a file or change a resource, and need no argument that runs code.
+ * Absent on purpose: commands that run the repository's own code (test
+ * runners, builds, package scripts, a package manager the repository pins or
+ * extends — on an untrusted repository someone else wrote that code), commands
+ * a repository's own config can point at another endpoint with the user's
+ * credentials (`.npmrc`, `.sentryclirc`, a Terraform or Pulumi backend), and
+ * commands whose usual output is a secret.
+ */
+declare const DEFAULT_PLANNER_ALLOWLIST: readonly string[];
+
+/** A delegated task's budget: tokens, and optionally wall-clock time (ADR-0056 M5). */
+interface DelegatedBudget {
+    tokens: number;
+    wallClockMs?: number;
+}
+/** Where a child plan's tasks stand now: the counts a delegated task's row shows while its child runs (ADR-0055 D20). */
+interface ChildTaskCounts {
+    completed: number;
+    running: number;
+    /** Waiting on a person, a checkpoint among them. */
+    waiting: number;
+    pending: number;
+    failed: number;
+    skipped: number;
+}
+/**
+ * What a delegated task's row says beyond any task's (ADR-0055 D16, D20): all of
+ * it derived where it is read, from the child's plan, the tree's ledger and the
+ * Stop, never kept. Every part is absent when there is nothing to say.
+ */
+interface DelegatedRow {
+    /** The child's tasks by where they stand; absent with no child session open. */
+    tasks?: ChildTaskCounts;
+    /** The task's token budget, and what the tree has not yet spent of it, across every child it has had (ADR-0056 M10). */
+    tokens?: {
+        budget: number;
+        left: number;
+    };
+    /** A Stop is still winding the subtree down, though the task already reads as not started (D16). */
+    stopping?: true;
+}
+/** What a task declares it works on (ADR-0057 R6). Advisory: nothing gates on it. */
+interface TaskScope {
+    paths?: string[];
+    provides?: string[];
+    consumes?: string[];
+}
+/** Something a check is made of. A `command` is the check itself at any length, where prose says little until it has some. */
+interface CheckWord {
+    text: string;
+    command: boolean;
+}
+
+/**
+ * The effect allowlist (ADR-0035): the user's standing approval for named
+ * effects, beside the planner allowlist, which names reads. It pre-approves a
+ * script task whose `commands` are all covered; it never covers a `script`
+ * body, whose shell text no rule can be matched against.
+ *
+ * A rule is matched against the whole command, every word in order and flags
+ * included, because an effect's flags change what it does: `git push origin
+ * feature/*` covers `git push origin feature/login`, never the same push with
+ * `--force`. `*` stands for one word, or inside a word for any run of
+ * characters, as in the planner allowlist, except that it never stands for
+ * what changes the effect: a flag (`--force`, and `/force` on Windows), a
+ * refspec's force or delete (`+main`, `:main`), or a `:` outside a URL
+ * (`feature/x:main`, which pushes to `main`). The rule writes any of those
+ * itself. A rule spells out its operation before any `*`, so
+ * `az webapp config * set` is no rule at all.
+ *
+ * Exclusions are the planner allowlist's `!` entries, with any `!` entry
+ * written here; an exclusion wins. A command exclusion is matched as the
+ * planner allowlist matches it; a path or URL exclusion holds for an argument
+ * that names an absolute path or URL it covers, whole or after a `=`, `@`,
+ * `:` or `,` or a short flag (`--url=…`, `-d @…`). A relative path is not
+ * resolved, since the body does not say where it runs. A program named by its
+ * path is a file the repository ships (ADR-0026), so it is never covered.
+ * There are no built-in rules: a default would pre-approve an effect the user
+ * never chose.
+ */
+interface EffectRule {
+    text: string;
+    binary: string;
+    words: RuleWord[];
+}
+interface EffectRules {
+    rules: EffectRule[];
+    exclusions: PlannerAllowlist;
+    platform: NodeJS.Platform;
+    /** The entries that are no rule, each with the warning that says why it is ignored. */
+    ignored: {
+        rule: string;
+        warning: string;
+    }[];
+}
+/**
+ * `entries` are the effect allowlist's; `plannerEntries` the planner allowlist
+ * in force, whose `!` entries hold here too; `platform` the one the commands
+ * run on, which decides how a flag is spelled and how a path resolves.
+ */
+declare function parseEffectAllowlist(entries: readonly string[], plannerEntries?: readonly string[], platform?: NodeJS.Platform): EffectRules;
+/**
+ * The rules, by name, that cover every command of a `commands` body, or null
+ * when one command is not covered, an exclusion holds for one, or the body is
+ * a `script`.
+ */
+declare function effectRuleFor(list: EffectRules, body: ScriptBody): string | null;
+
+/**
+ * The mandate (ADR-0056): what a node may do without a person, and within what
+ * limits. The root's is derived on each read from today's settings and never
+ * saved; a child's is one pure function of its parent's and its request, which
+ * can only narrow what the parent may hand on. Authority only: capability stays
+ * at the boundary a session runs in, and a prompt enforces nothing.
+ */
+declare const GRANTS: readonly ["observe", "steer", "control", "replan", "approve", "delegate", "effect", "research", "merge"];
+/** Each is a set of things a node may do unasked (M2). */
+type Grant = (typeof GRANTS)[number];
+/** What a mandate could not finish without: a child holds these unasked, and `narrow` refuses one that would lack any (M2). */
+declare const FLOOR_GRANTS: readonly Grant[];
+/** The shape of a tree, by ADR-0055 D19: refused past the hard cap, never dropped. */
+declare const SHAPE_LIMITS: {
+    readonly depth: {
+        readonly default: 2;
+        readonly hard: 4;
+    };
+    readonly delegatedTasks: {
+        readonly default: 8;
+        readonly hard: 30;
+    };
+    readonly tasksPerPlan: {
+        readonly default: 30;
+        readonly hard: 100;
+    };
+};
+interface MandateLimits {
+    /** The node's token budget; the root's is the tree's, from the delegation setting (M3, M5). */
+    tokens: number;
+    /** Null: no limit, which only the root has. */
+    wallClockMs: number | null;
+    /** How many levels may still open below this node. */
+    depth: number;
+    delegatedTasks: number;
+    tasksPerPlan: number;
+    runners: readonly RunnerId[];
+    /** The models a runner is held to; a runner not named may use any it offers, as the user's allowlist reads. */
+    models: Readonly<Record<RunnerId, readonly string[]>>;
+}
+interface MandateExclusions {
+    protectedPaths: readonly string[];
+}
+interface Mandate {
+    /** What this node may do. */
+    grants: ReadonlySet<Grant>;
+    /** What it may hand a child. */
+    grantable: ReadonlySet<Grant>;
+    /** Read in place of the global level. */
+    autonomy: 'full' | 'guarded';
+    limits: MandateLimits;
+    /** These only accumulate. */
+    exclusions: MandateExclusions;
+    /** One per level, each with its own `!` rules: a command must match at every level (M4). */
+    effectRules: readonly EffectRules[];
+    /** The level of `effectRules` this node's own request added: all of it a node keeps, the levels above being read as they stand (M1). */
+    ownEffectRules: readonly EffectRules[];
+}
+/** What the root's mandate is read from, each where it lives today (M1). */
+interface RootSettings {
+    /** The run's own copy: where a guard or a failure lowers it, and the user's change lands. */
+    level: SupervisorLevel;
+    autorun: boolean;
+    autonomous: boolean;
+    /** The tree's budget; 0 is delegation off (ADR-0055 D21). */
+    delegationTokens: number;
+    /** The effect allowlist, absent where nothing was read. */
+    effects?: EffectRules;
+    runners: readonly RunnerId[];
+    models: Readonly<Record<RunnerId, readonly string[]>>;
+}
+/** What a delegated task asks of the mandate it is given. `grants` names what it asks for past the floor; absent asks for nothing. */
+interface MandateRequest {
+    /** The level of the node narrowing, the root being 0: the one a refusal names. */
+    level: number;
+    grants?: readonly Grant[];
+    autonomy?: Mandate['autonomy'];
+    /** A delegated task must carry one (M5). */
+    tokens?: number;
+    wallClockMs?: number;
+    depth?: number;
+    delegatedTasks?: number;
+    tasksPerPlan?: number;
+    runners?: readonly RunnerId[];
+    models?: Readonly<Record<RunnerId, readonly string[]>>;
+    protectedPaths?: readonly string[];
+    effectRules?: EffectRules;
+}
+interface MandateRefusal {
+    level: number;
+    field: string;
+    asked: string;
+    there: string;
+}
+type Narrowed = {
+    ok: true;
+    mandate: Mandate;
+} | {
+    ok: false;
+    refusal: MandateRefusal;
+};
+declare function mandateRefusalText({ level, field, asked, there }: MandateRefusal): string;
+/**
+ * The root's mandate, as it stands now (M1): built afresh on each read, so an
+ * Act that a guard lowered reads Watch at the next check, and nothing saved
+ * could disagree with the settings.
+ */
+declare function rootMandate(settings: RootSettings): Mandate;
+/**
+ * What holds at a node now (M1): its saved mandate within every ancestor's
+ * `grantable` as it stands, under every ancestor's effect rules as they stand,
+ * so a change at the root reaches the subtree at the next check. This reading
+ * intersects and refuses nothing: the floor binds {@link narrow}, which writes
+ * a new child, not this.
+ */
+declare function heldMandate(saved: Mandate, ancestors: readonly Mandate[]): Mandate;
+/**
+ * A child's mandate (M4), or the refusal that names the level that refused,
+ * the field, what was asked and what is there. Pure, and written to be proved:
+ * no result is wider than its parent. `parent.limits.tokens` and `wallClockMs`
+ * are what the parent has left, which is the caller's to read.
+ */
+declare function narrow(parent: Mandate, request: MandateRequest): Narrowed;
+/** What a node reads of its own authority, at each check (M1). */
+interface NodeAuthority {
+    /** How far below the root, which is 0 and where a person remains. */
+    readonly depth: number;
+    /** The mandate that holds now. `level` is what the root's is read at; a child's does not depend on it. */
+    mandate(level: SupervisorLevel): Mandate;
+}
+/** The root: its settings read as each check asks, the level included, which each caller names. */
+declare function rootAuthority(settings: () => Omit<RootSettings, 'level'>): NodeAuthority;
+
 /** How many times a loop's check runs when the loop sets no `maxRounds`. */
 declare const DEFAULT_LOOP_ROUNDS = 3;
 /** The most rounds a loop may set: past it, the fix is not converging, and a person should look. */
@@ -1423,6 +2128,8 @@ interface SupervisionMemorySnapshot {
     edits: EditMemory;
     /** The keys of the guard trips the user was already told of. */
     told: string[];
+    /** The tasks the user stopped and has not started again. Absent on saves before it. */
+    stopped?: string[];
 }
 /** What the supervisor's own edits did this run: the tasks it removed, and each field it changed. */
 interface EditMemory {
@@ -1438,16 +2145,20 @@ interface EditMemory {
 }
 
 /**
- * When the supervisor wakes during a run, and what it is told (#27). Only an
- * attention event wakes it; passes ride along as context. It keeps no clock:
- * the host stamps each event and polls on its own tick.
+ * When the supervisor wakes during a run (#27, ADR-0057 R4). The decision is
+ * {@link wakeDue}, a pure function of the events held and what the plan says:
+ * no model, and no clock of its own, since the host stamps each event and polls
+ * on its own tick. A pass opens nothing and rides along as context. An event a
+ * person or a planner is waiting on wakes at once, which is ADR-0029's merge
+ * window. Anything else is held until the plan says it is time, or until the
+ * planner's prompt cache would go cold.
  *
  * `task_report` is a task addressed to the planner ending: one whose result a
  * planner turn asked for and did not get before it answered (ADR-0037, R2).
- * It is batched as any attention event is, and wakes the planner whatever the
- * supervisor's level, since the planner asked for it.
+ * It wakes the planner whatever the supervisor's level, since the planner
+ * asked for it.
  */
-type RunEventKind = 'task_passed' | 'task_failed' | 'waiting_input' | 'waiting_approval' | 'task_idle' | 'landing_conflict' | 'usage_limit' | 'auto_merge_stopped' | 'run_finished' | 'task_report';
+type RunEventKind = 'task_passed' | 'task_failed' | 'waiting_input' | 'waiting_approval' | 'approval_denied' | 'task_idle' | 'landing_conflict' | 'usage_limit' | 'auto_merge_stopped' | 'start_refused' | 'run_finished' | 'task_report';
 type RunEvent = {
     kind: RunEventKind;
     taskId?: string;
@@ -1473,7 +2184,7 @@ interface TaskReportEvent {
 }
 /** What the policy holds before its next wake-up, for the plan (ADR-0029). */
 interface WakePolicySnapshot {
-    /** Attention events inside the debounce window, in arrival order. */
+    /** The events waiting for a wake-up, in arrival order. */
     attention: RunEvent[];
     /** The passes since the previous wake-up. */
     sinceLast: RunEvent[];
@@ -1490,6 +2201,8 @@ interface SupervisorSnapshot {
     policy: WakePolicySnapshot;
     /** When each wake-up since the last pass was delivered, for the wake-up rate guard. */
     wakeUps: number[];
+    /** The user's Stop stands: a reload is not them starting the run again (ADR-0029). */
+    stopped?: true;
 }
 
 interface UserStep {
@@ -1502,7 +2215,7 @@ interface UserStep {
  * `script_exit` is a script task's exit status, its one evidence (ADR-0035).
  */
 interface VerificationCheck {
-    name: 'exit_code' | 'completion_marker' | 'task_complete' | 'manual' | 'script_exit';
+    name: 'exit_code' | 'completion_marker' | 'task_complete' | 'manual' | 'script_exit' | 'protected_paths';
     passed: boolean;
     /** A check that did not apply. Skipped checks don't affect the verdict. */
     skipped: boolean;
@@ -1520,7 +2233,8 @@ interface Verdict {
      * `done` on exit 0, `failed` on a non-zero exit, a signal or its time limit,
      * `blocked` when it could not start. A loop starts a round only on `failed`
      * (ADR-0045 L2). Absent when nothing reported: a runner that exited without
-     * the call, Mark complete, a stopped script, a verdict saved before it was kept.
+     * the call, Mark complete, a stopped script, an attempt the host died in, a
+     * verdict saved before it was kept.
      */
     reported?: 'done' | 'failed' | 'blocked';
 }
@@ -1532,8 +2246,11 @@ interface TaskOutputSummary {
     logTail: string;
     capturedAt: string;
 }
-/** `script` is an ops task whose body Ordewell runs with no model (ADR-0035). */
-type TaskType = 'ai' | 'user' | 'script';
+/**
+ * `script` is an ops task whose body Ordewell runs with no model (ADR-0035);
+ * `delegated` holds a goal, and its attempt is a child plan (ADR-0055).
+ */
+type TaskType = 'ai' | 'user' | 'script' | 'delegated';
 /**
  * `skipped` is terminal and verdict-less: the task will not be waited for, and
  * nothing it did lands. Its dependents go ahead without it once the work it
@@ -1550,7 +2267,7 @@ type TaskMode = string;
  * usage limit. Saved, so no surface has to guess it from whether an attempt
  * is live.
  */
-type AwaitingReason = 'input' | 'checkpoint' | 'conflict' | 'files-changed' | 'usage-limit';
+type AwaitingReason = 'input' | 'checkpoint' | 'question-lost' | 'conflict' | 'files-changed' | 'usage-limit';
 declare function isAwaitingReason(value: unknown): value is AwaitingReason;
 interface TaskModelAssignment {
     modelId: string;
@@ -1615,6 +2332,19 @@ interface Task {
     runnerSessionOwner?: RunnerId;
     /** Set only while `status` is `awaiting_user`, and not always then — a pause saved by an older build has none. */
     awaitingReason?: AwaitingReason;
+    /**
+     * The question a delegated task's subplanner is parked on (ADR-0056 M8). The
+     * live one is held in memory by what answers it, so this copy is only what a
+     * restart can still say was lost (ADR-0055 D17). Goes with the wait.
+     */
+    parkedQuestion?: string;
+    /**
+     * How many waits have ended since its latest attempt started, or since the
+     * task was written if none has: an attempt can wait many times, and this
+     * tells one wait from the next in an escalation's id (ADR-0053). Saved with
+     * the plan, so the id holds across a reload. Absent counts as none.
+     */
+    waitsEnded?: number;
     /**
      * When a task paused on its runner's usage limit is resumed on its own (ISO
      * time): the reset the runner announced, plus a short margin. Absent when no
@@ -1630,6 +2360,12 @@ interface Task {
     carriedFrom?: RunnerId;
     /** Why the task was skipped, as whoever skipped it put it; set only while `status` is `skipped`, and not always then. */
     skipReason?: string;
+    /**
+     * The user reverted its landed work (ADR-0054): saved with the plan, so the
+     * hold that keeps it from running again outlives this process. Set only
+     * while it waits as the revert left it: its next start clears it.
+     */
+    reverted?: true;
     /**
      * An ops task (ADR-0020): it changes no repository files, runs at the
      * workspace root rather than in a worktree, and waits for the change tasks
@@ -1678,6 +2414,22 @@ interface Task {
     script?: string;
     /** A script task's time limit; absent means ten minutes (`DEFAULT_SCRIPT_TIMEOUT_MS`). */
     timeoutMs?: number;
+    /** What a delegated task's child plan must achieve, in place of a prompt (ADR-0055 D1). */
+    goal?: string;
+    /** A delegated task's budget (ADR-0056 M5). */
+    budget?: DelegatedBudget;
+    /** What a delegated task asks for past the floor; absent asks for nothing (ADR-0056 M2). */
+    grants?: Grant[];
+    /** The paths a delegated task's child may not change, what its check runs among them (ADR-0055 D7). */
+    protectedPaths?: string[];
+    /** What a delegated task declares it works on (ADR-0057 R6). */
+    scope?: TaskScope;
+    /**
+     * On a delegated task, it answers a question and lands nothing (ADR-0055 D1).
+     * On a script task, it runs sealed in a throwaway worktree, past no gate (D8).
+     * A read-only AI task says so by its mode (ADR-0031) and stores none.
+     */
+    readOnly?: boolean;
     /** Set on a loop's check (ADR-0045): the tasks that fix what it finds, and how many times it may run. */
     loop?: TaskLoop;
     /**
@@ -1709,6 +2461,9 @@ type TaskReportTo = ({
 } | {
     actor: 'supervisor';
     level: SupervisorLevel;
+} | {
+    actor: 'subplanner';
+    depth: number;
 });
 /** Whose authority a turn opened without the user acts with (ADR-0037, R3): the user's turn, or the supervisor's. */
 type TurnAuthority = 'user' | 'supervisor';
@@ -1995,6 +2750,13 @@ interface PendingPlanTurn {
      * the user's turn, which the turn then acts as (R3).
      */
     report?: TurnAuthority;
+    /**
+     * The tasks a supervisor input is wholly about, absent when any of it is about
+     * the run. While the user has stopped all of them it opens no turn (ADR-0029).
+     */
+    tasks?: string[];
+    /** It goes with the next turn and opens none (ADR-0057 R6). */
+    rides?: true;
 }
 /**
  * The run's own copy of the user's run settings (ADR-0030): taken when the
@@ -2192,4 +2954,4 @@ type ApprovalRecord = Pick<LegacyPlanState, 'approved' | 'approvedTasks'>;
  */
 declare function waitsForApproval(task: Pick<Task, 'id' | 'type' | 'status'>, record: ApprovalRecord): boolean;
 
-export { type IsolationTaskStatus as $, type ApprovalRecord as A, BUILTIN_SKILL_NAMES as B, type ContextCheckpoint as C, DEFAULT_LOOP_ROUNDS as D, type ExecutionActor as E, type FindingSeverity as F, type GuardTarget as G, HANDOFF_LIMITS as H, type IIsolationPreview as I, type IsolationAvailability as J, type IsolationHandoff as K, type IsolationHandoffRepo as L, type IsolationInactiveReason as M, type IsolationLandedTask as N, type IsolationLanding as O, type IsolationMergeBlock as P, type IsolationMergeBlockReason as Q, type IsolationMergeResult as R, type IsolationOutcome as S, type IsolationPreview as T, type IsolationPruneResult as U, type IsolationRemoval as V, type IsolationRepo as W, type IsolationRun as X, type IsolationTaskRecord as Y, type IsolationTaskRef as Z, type IsolationTaskRepo as _, type AttemptUsage as a, type TaskSkillSnapshot as a$, type IsolationView as a0, type LegacyPlanState as a1, type LoopSubject as a2, MAX_LOOP_ROUNDS as a3, type ModelUsage as a4, type PatchFlag as a5, type PatchView as a6, type PendingPlanTurn as a7, type PlanIsolation as a8, type PlanState as a9, type RunnerSessionCost as aA, SEVERITY_LABEL as aB, type ScriptConsent as aC, type ScriptResult as aD, type SessionBilling as aE, type SetupFailure as aF, type ShadowedSkill as aG, type SkillAppliesTo as aH, type SkillCatalog as aI, type SkillInfo as aJ, type SkillLoad as aK, type SkillLoadNotice as aL, type SkillMetadata as aM, type SkillSource as aN, SkillsService as aO, type StoredHandoff as aP, type SubagentOutcome as aQ, type SupervisorLevel as aR, type Task as aS, type TaskDiffRead as aT, type TaskDiffResult as aU, type TaskIsolation as aV, type TaskIsolationState as aW, type TaskLoop as aX, type TaskModelAssignment as aY, type TaskReportTo as aZ, type TaskSkillNotice as a_, type PlanStatus as aa, type PlanUsage as ab, type PlannerCompaction as ac, type PlannerCompactionOutcome as ad, type PlannerContextPause as ae, type PlannerResendState as af, type PlannerUsage as ag, type PrepareIntent as ah, type PreparedTask as ai, type PreservedWork as aj, type PreviewRepo as ak, type PreviousWork as al, REPORT_MAX_CHARS as am, type RefusedRemoval as an, type RepairEvidence as ao, type ReplyRun as ap, type RepoGroupLayout as aq, type RepoHead as ar, type ReportedWindow as as, type ResearchLogEntry as at, type ResearchProgress as au, type ResearchStep as av, type ResearchStepOutcome as aw, type ResearchToolType as ax, type RunSettings as ay, type RunnerId as az, type AwaitingReason as b, resumedSessionWindow as b$, type TaskSnapshot as b0, type TaskStatus as b1, type TaskType as b2, type TaskUsageSummary as b3, type TreeSnapshot as b4, type UsageLine as b5, type UsageRecord as b6, type UsageTotals as b7, type Verdict as b8, type VerificationCheck as b9, handoffPreviewLines as bA, handoffReferenceText as bB, handoffWakeLines as bC, inLoop as bD, isAwaitingReason as bE, isMeasured as bF, isSupervisorLevel as bG, isUserMessage as bH, loopRemovalRefusal as bI, loopRoundOf as bJ, migratePlanState as bK, modelCostTitle as bL, namedHandoff as bM, openingLines as bN, outOfRounds as bO, partedPromptUsage as bP, patchChangesText as bQ, patchFlagText as bR, patchLines as bS, patchLinesText as bT, patchText as bU, patchView as bV, pausedOnLimit as bW, planUsage as bX, plannerContextFill as bY, readableTaskIds as bZ, rejoinPlanTree as b_, addAttemptUsage as ba, addModelUsage as bb, addPlannerUsage as bc, addUsage as bd, addUsageTotals as be, artifactLines as bf, betweenRounds as bg, boundedHandoffLines as bh, byteSize as bi, checkHandoff as bj, checkOf as bk, contextMeterText as bl, contextMeterTitle as bm, costText as bn, countedSessionCost as bo, createEmptyPlan as bp, createSkillsService as bq, createTask as br, endAttemptUsage as bs, findingLines as bt, flattenTasks as bu, flattenTasksWithParents as bv, formatCost as bw, formatTokenCount as bx, handoffDigest as by, handoffLines as bz, type ContextFill as c, savedPatchOf as c0, savedPatchView as c1, savedPatchViews as c2, severityLabel as c3, startAttemptUsage as c4, storedHandoff as c5, subagentCostTitle as c6, taskUsageSummary as c7, tasksTotalText as c8, usageLine as c9, usageText as ca, waitsForApproval as cb, withPatch as cc, worstSeverity as cd, type ConversationMessage as d, type CostProvenance as e, DEFAULT_RUNNERS as f, DEFAULT_SUPERVISOR_RETRY_LIMIT as g, DIGEST_FINDINGS as h, type DiscoveredModel as i, type ExecutionCommandName as j, type ExecutionRecord as k, type GuardTrip as l, HANDOFF_PUSH_CHARS as m, type Handoff as n, type HandoffArtifact as o, type HandoffCheck as p, type HandoffCommit as q, type HandoffDigest as r, type HandoffEvidence as s, type HandoffFinding as t, type HandoffPatch as u, type HandoffPreviewOptions as v, type HandoffTaskName as w, type IWorktreeIsolation as x, type IntegrationDisposal as y, type InvalidSkill as z };
+export { type IsolationLanding as $, type ApprovalRecord as A, BUILTIN_SKILL_NAMES as B, type CheckWord as C, DEFAULT_LOOP_ROUNDS as D, type EffectRules as E, FLOOR_GRANTS as F, GRANTS as G, HANDOFF_LIMITS as H, type HandoffCheck as I, type HandoffCommit as J, type HandoffDigest as K, type HandoffEvidence as L, type HandoffFinding as M, type HandoffLogs as N, type HandoffPatch as O, type HandoffPins as P, type HandoffPreviewOptions as Q, type HandoffTaskName as R, type IIsolationPreview as S, type IWorktreeIsolation as T, type IntegrationDisposal as U, type InvalidSkill as V, type IsolationAvailability as W, type IsolationHandoff as X, type IsolationHandoffRepo as Y, type IsolationInactiveReason as Z, type IsolationLandedTask as _, type AttemptUsage as a, type RevertCommand as a$, type IsolationMergeBlock as a0, type IsolationMergeBlockReason as a1, type IsolationMergeResult as a2, type IsolationOutcome as a3, type IsolationPreview as a4, type IsolationPruneResult as a5, type IsolationRemoval as a6, type IsolationRepo as a7, type IsolationRepoRevert as a8, type IsolationRevertResult as a9, type PlanUsage as aA, type PlannerAllowlist as aB, type PlannerCompaction as aC, type PlannerCompactionOutcome as aD, type PlannerContextPause as aE, type PlannerResendState as aF, type PlannerUsage as aG, type PrepareIntent as aH, type PreparedTask as aI, type PreservedWork as aJ, type PreviewRepo as aK, type PreviousWork as aL, REPORT_MAX_CHARS as aM, ROOT_NODE as aN, type RefusedRemoval as aO, type RepairEvidence as aP, type RepairWait as aQ, type ReplyRun as aR, type RepoGroupLayout as aS, type RepoHead as aT, type ReportItem as aU, type ReportedWindow as aV, type ResearchLogEntry as aW, type ResearchProgress as aX, type ResearchStep as aY, type ResearchStepOutcome as aZ, type ResearchToolType as a_, type IsolationRevertTask as aa, type IsolationRun as ab, type IsolationTaskRecord as ac, type IsolationTaskRef as ad, type IsolationTaskRepo as ae, type IsolationTaskStatus as af, type IsolationView as ag, type LandedTask as ah, type LandedWork as ai, type LegacyPlanState as aj, type LoopSubject as ak, MAX_LOOP_ROUNDS as al, type Mandate as am, type MandateExclusions as an, type MandateLimits as ao, type MandateRefusal as ap, type MandateRequest as aq, type ModelUsage as ar, type Narrowed as as, type NodeAuthority as at, type PatchFlag as au, type PatchView as av, type PendingPlanTurn as aw, type PlanIsolation as ax, type PlanState as ay, type PlanStatus as az, type AwaitingReason as b, costText as b$, type RevertWatch as b0, type RootSettings as b1, type RunSettings as b2, type RunnerId as b3, type RunnerSessionCost as b4, SEVERITY_LABEL as b5, SHAPE_LIMITS as b6, type ScriptBody as b7, type ScriptConsent as b8, type ScriptResult as b9, type TaskSnapshot as bA, type TaskStatus as bB, type TaskType as bC, type TaskUsageSummary as bD, type TreeSnapshot as bE, type UsageLine as bF, type UsageRecord as bG, type UsageTotals as bH, type Verdict as bI, type VerificationCheck as bJ, type WrittenTaskRef as bK, actorAuthority as bL, addAttemptUsage as bM, addModelUsage as bN, addPlannerUsage as bO, addUsage as bP, addUsageTotals as bQ, artifactLines as bR, betweenRounds as bS, boundedHandoffLines as bT, byteSize as bU, checkHandoff as bV, checkOf as bW, commandAllowedBy as bX, commandLine as bY, contextMeterText as bZ, contextMeterTitle as b_, type SessionBilling as ba, type SetupFailure as bb, type ShadowedSkill as bc, type SkillAppliesTo as bd, type SkillCatalog as be, type SkillInfo as bf, type SkillLoad as bg, type SkillLoadNotice as bh, type SkillMetadata as bi, type SkillSource as bj, SkillsService as bk, type StoredHandoff as bl, type SubagentOutcome as bm, type SubtreeReport as bn, type SupervisorLevel as bo, type Task as bp, type TaskDiffRead as bq, type TaskDiffResult as br, type TaskEvidence as bs, type TaskIsolation as bt, type TaskIsolationState as bu, type TaskLoop as bv, type TaskModelAssignment as bw, type TaskReportTo as bx, type TaskSkillNotice as by, type TaskSkillSnapshot as bz, type BelowPlan as c, scriptTaskText as c$, countedSessionCost as c0, createEmptyPlan as c1, createSkillsService as c2, createTask as c3, effectRuleFor as c4, endAttemptUsage as c5, findingLines as c6, findingRefText as c7, flattenTasks as c8, flattenTasksWithParents as c9, parseEffectAllowlist as cA, parseFindingRef as cB, parsePlanPath as cC, partedPromptUsage as cD, patchChangesText as cE, patchFlagText as cF, patchLines as cG, patchLinesText as cH, patchText as cI, patchView as cJ, pausedOnLimit as cK, pinReference as cL, planUsage as cM, plannerContextFill as cN, readableTaskIds as cO, rejoinPlanTree as cP, removedAttempt as cQ, resolveWrittenRef as cR, resumedSessionWindow as cS, rootAuthority as cT, rootMandate as cU, savedPatchOf as cV, savedPatchView as cW, savedPatchViews as cX, scopeAllowed as cY, scriptBodyOf as cZ, scriptBodyText as c_, formatCost as ca, formatTokenCount as cb, handoffDigest as cc, handoffLines as cd, handoffPreviewLines as ce, handoffReferenceText as cf, handoffWakeLines as cg, heldHandoff as ch, heldMandate as ci, heldWords as cj, inLoop as ck, isAwaitingReason as cl, isMeasured as cm, isSupervisorLevel as cn, isUserMessage as co, loopRemovalRefusal as cp, loopRoundOf as cq, mandateRefusalText as cr, migratePlanState as cs, modelCostTitle as ct, namedHandoff as cu, narrow as cv, nodeText as cw, openingLines as cx, outOfRounds as cy, parseAllowlist as cz, type ChildTaskCounts as d, severityLabel as d0, spentTokens as d1, startAttemptUsage as d2, storedHandoff as d3, subagentCostTitle as d4, taskUsageSummary as d5, tasksTotalText as d6, timeLimitText as d7, toolAllowed as d8, usageLine as d9, usageText as da, waitsForApproval as db, withPatch as dc, wordsFrom as dd, worstSeverity as de, type CommandWords as e, type ContextCheckpoint as f, type ContextFill as g, type ConversationMessage as h, type CostProvenance as i, DEFAULT_PLANNER_ALLOWLIST as j, DEFAULT_RUNNERS as k, DEFAULT_SCRIPT_TIMEOUT_MS as l, DEFAULT_SUPERVISOR_RETRY_LIMIT as m, DIGEST_FINDINGS as n, type DelegatedRow as o, type DiscoveredModel as p, type ExecutionActor as q, type ExecutionCommandName as r, type ExecutionRecord as s, type FindingSeverity as t, type Grant as u, type GuardTarget as v, type GuardTrip as w, HANDOFF_PUSH_CHARS as x, type Handoff as y, type HandoffArtifact as z };