@ordewell/core 0.11.2 → 0.12.0

package/dist/{Task-BL4Idm9r.d.mts → Task-BTEH-ztX.d.mts}

@@ -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 plan a pinned reference is under while every plan is the root's (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.
  */
@@ -23,7 +28,9 @@ type HandoffEvidence = {
     resolved?: boolean;
 } | {
     kind: 'task';
+    node?: string;
     task: string;
+    attempt?: number;
     finding?: string;
 } | {
     kind: 'url';
@@ -93,6 +100,8 @@ 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;
 }
 /** The whole handoff, as the attempt's log keeps it. */
 interface StoredHandoff extends HandoffDigest {
@@ -144,7 +153,43 @@ 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 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[], readerId: 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;
@@ -197,6 +242,12 @@ declare function findingLines(f: HandoffFinding, taskName?: HandoffTaskName): st
 declare function artifactLines(handoff: HandoffDigest, taskName?: HandoffTaskName): string[];
 /** 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,15 +290,33 @@ 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;
+}
 /**
  * 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 {
     repo?: string;
@@ -445,10 +514,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 +533,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
@@ -511,6 +592,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 +656,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 +680,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 +830,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`,
@@ -806,6 +1024,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 +1072,12 @@ 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.
+     * 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[]>;
     /**
@@ -1153,7 +1388,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 +1398,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 +1425,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
@@ -1423,6 +1668,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,14 +1685,18 @@ 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 RunEvent = {
@@ -1473,7 +1724,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 +1741,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 {
@@ -1520,7 +1773,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';
 }
@@ -1615,6 +1869,13 @@ 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;
+    /**
+     * 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 +1891,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
@@ -1709,6 +1976,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 +2265,11 @@ 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[];
 }
 /**
  * The run's own copy of the user's run settings (ADR-0030): taken when the
@@ -2192,4 +2467,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 IsolationRevertTask 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 IntegrationDisposal as J, type InvalidSkill as K, type IsolationAvailability as L, type IsolationHandoff as M, type IsolationHandoffRepo as N, type IsolationInactiveReason as O, type IsolationLandedTask as P, type IsolationLanding as Q, type IsolationMergeBlock as R, type IsolationMergeBlockReason as S, type IsolationMergeResult as T, type IsolationOutcome as U, type IsolationPreview as V, type IsolationPruneResult as W, type IsolationRemoval as X, type IsolationRepo as Y, type IsolationRepoRevert as Z, type IsolationRevertResult as _, type AttemptUsage as a, type SubagentOutcome as a$, type IsolationRun as a0, type IsolationTaskRecord as a1, type IsolationTaskRef as a2, type IsolationTaskRepo as a3, type IsolationTaskStatus as a4, type IsolationView as a5, type LandedTask as a6, type LandedWork as a7, type LegacyPlanState as a8, type LoopSubject as a9, type RepoHead as aA, type ReportedWindow as aB, type ResearchLogEntry as aC, type ResearchProgress as aD, type ResearchStep as aE, type ResearchStepOutcome as aF, type ResearchToolType as aG, type RevertCommand as aH, type RevertWatch as aI, type RunSettings as aJ, type RunnerId as aK, type RunnerSessionCost as aL, SEVERITY_LABEL as aM, type ScriptConsent as aN, type ScriptResult as aO, type SessionBilling as aP, type SetupFailure as aQ, type ShadowedSkill as aR, type SkillAppliesTo as aS, type SkillCatalog as aT, type SkillInfo as aU, type SkillLoad as aV, type SkillLoadNotice as aW, type SkillMetadata as aX, type SkillSource as aY, SkillsService as aZ, type StoredHandoff as a_, MAX_LOOP_ROUNDS as aa, type ModelUsage as ab, type PatchFlag as ac, type PatchView as ad, type PendingPlanTurn as ae, type PlanIsolation as af, type PlanState as ag, type PlanStatus as ah, type PlanUsage as ai, type PlannerCompaction as aj, type PlannerCompactionOutcome as ak, type PlannerContextPause as al, type PlannerResendState as am, type PlannerUsage as an, type PrepareIntent as ao, type PreparedTask as ap, type PreservedWork as aq, type PreviewRepo as ar, type PreviousWork as as, REPORT_MAX_CHARS as at, ROOT_NODE as au, type RefusedRemoval as av, type RepairEvidence as aw, type RepairWait as ax, type ReplyRun as ay, type RepoGroupLayout as az, type AwaitingReason as b, openingLines as b$, type SupervisorLevel as b0, type Task as b1, type TaskDiffRead as b2, type TaskDiffResult as b3, type TaskIsolation as b4, type TaskIsolationState as b5, type TaskLoop as b6, type TaskModelAssignment as b7, type TaskReportTo as b8, type TaskSkillNotice as b9, costText as bA, countedSessionCost as bB, createEmptyPlan as bC, createSkillsService as bD, createTask as bE, endAttemptUsage as bF, findingLines as bG, findingRefText as bH, flattenTasks as bI, flattenTasksWithParents as bJ, formatCost as bK, formatTokenCount as bL, handoffDigest as bM, handoffLines as bN, handoffPreviewLines as bO, handoffReferenceText as bP, handoffWakeLines as bQ, inLoop as bR, isAwaitingReason as bS, isMeasured as bT, isSupervisorLevel as bU, isUserMessage as bV, loopRemovalRefusal as bW, loopRoundOf as bX, migratePlanState as bY, modelCostTitle as bZ, namedHandoff as b_, type TaskSkillSnapshot as ba, type TaskSnapshot as bb, type TaskStatus as bc, type TaskType as bd, type TaskUsageSummary as be, type TreeSnapshot as bf, type UsageLine as bg, type UsageRecord as bh, type UsageTotals as bi, type Verdict as bj, type VerificationCheck as bk, type WrittenTaskRef as bl, actorAuthority as bm, addAttemptUsage as bn, addModelUsage as bo, addPlannerUsage as bp, addUsage as bq, addUsageTotals as br, artifactLines as bs, betweenRounds as bt, boundedHandoffLines as bu, byteSize as bv, checkHandoff as bw, checkOf as bx, contextMeterText as by, contextMeterTitle as bz, type ContextFill as c, outOfRounds as c0, parseFindingRef as c1, partedPromptUsage as c2, patchChangesText as c3, patchFlagText as c4, patchLines as c5, patchLinesText as c6, patchText as c7, patchView as c8, pausedOnLimit as c9, planUsage as ca, plannerContextFill as cb, readableTaskIds as cc, rejoinPlanTree as cd, removedAttempt as ce, resolveWrittenRef as cf, resumedSessionWindow as cg, savedPatchOf as ch, savedPatchView as ci, savedPatchViews as cj, severityLabel as ck, startAttemptUsage as cl, storedHandoff as cm, subagentCostTitle as cn, taskUsageSummary as co, tasksTotalText as cp, usageLine as cq, usageText as cr, waitsForApproval as cs, withPatch as ct, wordsFrom as cu, worstSeverity as cv, 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 HandoffLogs as u, type HandoffPatch as v, type HandoffPins as w, type HandoffPreviewOptions as x, type HandoffTaskName as y, type IWorktreeIsolation as z };