@ordewell/core 0.11.2 → 0.12.0

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

@@ -1,6 +1,6 @@
-import { aP as StoredHandoff, aS as Task, az as RunnerId, b0 as TaskSnapshot, b as AwaitingReason, b6 as UsageRecord, aA as RunnerSessionCost, i as DiscoveredModel, aO as SkillsService, aJ as SkillInfo, aq as RepoGroupLayout, x as IWorktreeIsolation, X as IsolationRun, K as IsolationHandoff, a8 as PlanIsolation, Y as IsolationTaskRecord, aV as TaskIsolation, a0 as IsolationView, ah as PrepareIntent, al as PreviousWork, q as HandoffCommit, S as IsolationOutcome, ao as RepairEvidence, b4 as TreeSnapshot, aT as TaskDiffRead, aU as TaskDiffResult, R as IsolationMergeResult, b8 as Verdict, a1 as LegacyPlanState, aZ as TaskReportTo, a$ as TaskSkillSnapshot, a_ as TaskSkillNotice, aQ as SubagentOutcome, d as ConversationMessage, aL as SkillLoadNotice, a7 as PendingPlanTurn, r as HandoffDigest, a as AttemptUsage, aX as TaskLoop, ay as RunSettings, ab as PlanUsage, ap as ReplyRun, aE as SessionBilling, a4 as ModelUsage, b7 as UsageTotals, c as ContextFill, ac as PlannerCompaction, k as ExecutionRecord, av as ResearchStep, a9 as PlanState, b1 as TaskStatus, E as ExecutionActor, l as GuardTrip, aR as SupervisorLevel, j as ExecutionCommandName, G as GuardTarget, au as ResearchProgress, at as ResearchLogEntry, aK as SkillLoad, ae as PlannerContextPause, aa as PlanStatus, P as IsolationMergeBlock, N as IsolationLandedTask, T as IsolationPreview, ax as ResearchToolType, a2 as LoopSubject, aw as ResearchStepOutcome, ad as PlannerCompactionOutcome, ag as PlannerUsage, F as FindingSeverity, b2 as TaskType, a6 as PatchView, aW as TaskIsolationState, b3 as TaskUsageSummary } from './Task-BL4Idm9r.js';
-import { q as ApprovalRequest, r as ApprovalSource, N as IApproval, br as ToolOutcome, R as IRunnerSession, O as IConfig, bs as UsageLimitSignal, be as TaskMessageFrom, aN as RunnerModelRef, aE as RunnerCommand, aK as RunnerMcpServer, b6 as StructuredTurnEnd, k as ApprovalDecision, aZ as ScriptRun, a_ as ScriptStatus, b5 as StructuredEvent, ar as QueuedTaskMessage, l as ApprovalKind, Q as IRunner, aO as RunnerRegistry, bm as TaskShellSite, bl as TaskShell, aW as ScriptBody, d as AgentProcessDeps, a as AgentAdapter, a9 as OrdewellMcpServer, P as IFileSystem, am as PlannerToolHandler, j as ApprovalAnswer, aJ as RunnerManifest, f as AiProvider, ag as PlannerBackendId, a8 as OrchestratorOption } from './IRunner-DOMtDTVt.js';
-import { R as RunnerModeInfo } from './ModeResolver-DyXeZ9ib.js';
+import { a_ as StoredHandoff, b1 as Task, aK as RunnerId, bb as TaskSnapshot, b as AwaitingReason, bh as UsageRecord, aL as RunnerSessionCost, i as DiscoveredModel, aZ as SkillsService, aU as SkillInfo, az as RepoGroupLayout, z as IWorktreeIsolation, a0 as IsolationRun, M as IsolationHandoff, af as PlanIsolation, a1 as IsolationTaskRecord, b4 as TaskIsolation, a5 as IsolationView, ao as PrepareIntent, as as PreviousWork, q as HandoffCommit, U as IsolationOutcome, aw as RepairEvidence, bf as TreeSnapshot, b2 as TaskDiffRead, b3 as TaskDiffResult, T as IsolationMergeResult, a7 as LandedWork, aI as RevertWatch, _ as IsolationRevertResult, bj as Verdict, a8 as LegacyPlanState, b8 as TaskReportTo, ba as TaskSkillSnapshot, b9 as TaskSkillNotice, a$ as SubagentOutcome, a2 as IsolationTaskRef, aH as RevertCommand, $ as IsolationRevertTask, d as ConversationMessage, aW as SkillLoadNotice, ae as PendingPlanTurn, r as HandoffDigest, a as AttemptUsage, b6 as TaskLoop, aJ as RunSettings, ai as PlanUsage, ay as ReplyRun, aP as SessionBilling, ab as ModelUsage, bi as UsageTotals, c as ContextFill, aj as PlannerCompaction, k as ExecutionRecord, aE as ResearchStep, ag as PlanState, ax as RepairWait, b0 as SupervisorLevel, bc as TaskStatus, E as ExecutionActor, l as GuardTrip, G as GuardTarget, j as ExecutionCommandName, aD as ResearchProgress, aC as ResearchLogEntry, aV as SkillLoad, al as PlannerContextPause, ah as PlanStatus, R as IsolationMergeBlock, P as IsolationLandedTask, V as IsolationPreview, aG as ResearchToolType, a9 as LoopSubject, aF as ResearchStepOutcome, ak as PlannerCompactionOutcome, an as PlannerUsage, F as FindingSeverity, bd as TaskType, ad as PatchView, b5 as TaskIsolationState, be as TaskUsageSummary } from './Task-BTEH-ztX.js';
+import { q as ApprovalRequest, r as ApprovalSource, N as IApproval, bs as ToolOutcome, R as IRunnerSession, O as IConfig, bt as UsageLimitSignal, be as TaskMessageFrom, aN as RunnerModelRef, aE as RunnerCommand, aK as RunnerMcpServer, b6 as StructuredTurnEnd, k as ApprovalDecision, aZ as ScriptRun, a_ as ScriptStatus, b5 as StructuredEvent, j as ApprovalAnswer, ar as QueuedTaskMessage, l as ApprovalKind, Q as IRunner, aO as RunnerRegistry, bn as TaskShellSite, bm as TaskShell, az as RuleWord, af as PlannerAllowlist, aW as ScriptBody, d as AgentProcessDeps, a as AgentAdapter, a9 as OrdewellMcpServer, P as IFileSystem, am as PlannerToolHandler, aJ as RunnerManifest, bk as TaskRunnerConfig, f as AiProvider, ag as PlannerBackendId, a8 as OrchestratorOption } from './IRunner-DjJkYwko.js';
+import { R as RunnerModeInfo } from './ModeResolver-CHsaoV7M.js';
 
 type NotificationAction = {
     label: string;
@@ -261,6 +261,8 @@ declare class PlanStore {
      * with the top-level task it hangs under.
      */
     isOps(taskId: string): boolean;
+    /** Every task's status and what it waits for, to tell cheaply whether one has changed since this was read. */
+    statusMark(): string;
     /** A copy of the task tree, detached from the store: later status changes do not reach it. */
     snapshot(): Task[];
     getExecutionLog(): ReadonlyArray<TaskSnapshot>;
@@ -274,13 +276,7 @@ declare class PlanStore {
     clearLog(): void;
     private notifyMutate;
     private countStatus;
-    /**
-     * `keepFailed` adopts failed tasks as failed: an edit reconciled into a run
-     * is not a retry, and the tasks it blocks wait for one (ADR-0034).
-     */
-    load(tasks: ReadonlyArray<Readonly<Task>>, runners: readonly RunnerId[], opts?: {
-        keepFailed?: boolean;
-    }): void;
+    load(tasks: ReadonlyArray<Readonly<Task>>, runners: readonly RunnerId[]): void;
     add(partial: Partial<Task>): Task;
     remove(taskId: string): void;
     update(taskId: string, changes: Partial<Task>): Task | undefined;
@@ -288,22 +284,36 @@ declare class PlanStore {
      * Run preparation as one named op: flip every AI and script task to 'approved'. By
      * default completed tasks keep their status so a reloaded half-finished plan
      * resumes the remainder instead of re-running work that already succeeded,
-     * and skipped ones stay skipped: a new run is not a retry of them.
+     * and skipped ones stay skipped: a new run is not a retry of them. A failed
+     * task gets its fresh chance here, not at a load (ADR-0053).
      * `preserveCompleted: false` is for a freshly committed plan, where
-     * everything starts over. `keepScheduledResumes` leaves a task waiting on
-     * its runner's usage-limit reset waiting: an edit adopted between runs is
-     * not the user starting over.
+     * everything starts over. `edited` is an edit adopted between runs, which is
+     * not the user starting over: a failed task stays failed, and a task waiting
+     * on the user, whatever for, stays waiting. `keepFailed` is what failed in
+     * the reply autorun's run follows: nobody asked for those to run again.
      */
     resetForRun(opts?: {
         preserveCompleted?: boolean;
-        keepScheduledResumes?: boolean;
+        edited?: boolean;
+        keepFailed?: ReadonlySet<string>;
     }): void;
+    /**
+     * Execute's fresh chance with work already live (ADR-0053), which
+     * `resetForRun` would take back: only what failed and is not at work is
+     * readied, and a check between rounds still leaves its body to run first.
+     */
+    readyFailed(live: (taskId: string) => boolean): void;
+    /** See {@link releaseMadeManual}; `live` names what a runner still holds. */
+    releaseMadeManual(live?: (taskId: string) => boolean): void;
+    private ready;
     markCompleted(id: string): void;
     markFailed(id: string): void;
     markSkipped(id: string, reason?: string): void;
     markInProgress(id: string): void;
     /** Its first attempt is starting: from now on its chat exists, whatever becomes of the attempt. */
     markAttempted(id: string): void;
+    /** Its attempt starts: the number now tells its waits from the last attempt's, so they count from nothing (ADR-0053). */
+    markAttemptStarted(id: string): void;
     markAwaitingUser(id: string, reason?: AwaitingReason): void;
     /** When a task paused on a usage limit resumes on its own; undefined leaves it to a manual retry. */
     setTaskResumeAt(id: string, resumeAt: string | undefined): void;
@@ -316,6 +326,8 @@ declare class PlanStore {
     retry(id: string, opts?: {
         sameRound?: boolean;
     }): void;
+    /** Its landed work was reverted (ADR-0054): as a retry leaves it, marked so until it starts. */
+    markReverted(id: string): void;
     /** A loop's check counts its rounds afresh from its next run (ADR-0045 L7). */
     startRoundsOver(id: string): void;
     /**
@@ -326,6 +338,10 @@ declare class PlanStore {
     repeat(id: string): void;
     /** Kept on the task: it was force-started past its merge gate, before these ancestors' work was merged (ADR-0020). */
     setForcedPastGate(id: string, dependencies: string[]): void;
+    /** One of the task's waits is over, so what it waits on next is another (ADR-0053). */
+    endWait(id: string): void;
+    /** Work under way is the one status nobody could be waiting on, so moving off any other ends a wait. */
+    private leaveStatus;
     /** A reason outlives nothing: any status but `awaiting_user` drops it, and the resume time with it; any status drops a skip's reason. */
     private setStatus;
     setTaskVerdict(id: string, verdict: Task['verdict']): void;
@@ -638,8 +654,12 @@ interface IsolationRunListener {
     handoff(handoff: IsolationHandoff): void;
     /** The run was cleared up and forgotten: nothing was handed over, or it was discarded. */
     closed(): void;
+    /** The run is over, discarded or cleared up, whether or not its record stays: nothing it carried goes on (ADR-0045 L5). A Merge all it goes on after is not this. */
+    ended(): void;
     /** Already said through the notifications; also for a surface that shows no toasts. */
     notice(level: IsolationNoticeLevel, message: string): void;
+    /** A clean-up took the branches these resolver tasks would merge, and their links with them. */
+    resolversEnded(resolverIds: readonly string[]): void;
 }
 interface IsolationRunControllerDeps {
     isolation: IWorktreeIsolation;
@@ -653,6 +673,8 @@ interface IsolationRunControllerDeps {
      * the user mid-attempt.
      */
     liveTasks: () => ReadonlySet<string>;
+    /** What a task depends on now, directly or not, read as it lands: the plan may let go of that later, and a revert may not (ADR-0054). */
+    landedOn: (taskId: string) => readonly string[];
 }
 /**
  * The lifecycle of a plan's isolation run (ADR-0013, ADR-0014, ADR-0020),
@@ -670,6 +692,7 @@ declare class IsolationRunController {
     private readonly workspaceRoot;
     private readonly listener;
     private readonly liveTasks;
+    private readonly landedOn;
     private run;
     /** See {@link mergedRun}. */
     private merged;
@@ -687,10 +710,13 @@ declare class IsolationRunController {
     /** Resolver task id → the conflicted task it resolves; see {@link linkResolver}. */
     private resolvers;
     private opening;
+    private opened;
     /** Bumped by an interrupt, so an activation in flight across it does not open the run it ended. */
     private activations;
     /** The start a dirty tree turned away, handed back once the user chooses how to go on. */
     private blockedStart;
+    /** How many starts it has turned away; a replay can be turned away again in the same run. */
+    private turnedAway;
     /** The dirty repos behind {@link blockedStart}, for the stash notice. */
     private blockedRepos;
     constructor(deps: IsolationRunControllerDeps);
@@ -705,12 +731,16 @@ declare class IsolationRunController {
      */
     get mergedRun(): string | null;
     get isOpen(): boolean;
+    /** How many runs have opened: what tells one run's launches from the next one's. */
+    get epoch(): number;
     /** The open run has decided whether it isolates. */
     get decided(): boolean;
     /** The open run executes in worktrees. */
     get isolating(): boolean;
     /** A run is waiting on the user to stash or to go on without isolation. */
     get blocked(): boolean;
+    /** How many starts a dirty tree has turned away: what tells one wait on it from the next (ADR-0053). */
+    get blockedStarts(): number;
     /** What the plan persists of isolated execution; null when no run ever isolated. */
     get planIsolation(): PlanIsolation | null;
     /** The one guard of every action on the run: a plan that never isolated is a request refused, not a fault. */
@@ -769,10 +799,11 @@ declare class IsolationRunController {
     /**
      * Go on with the start a dirty tree turned away. `stash` puts the user's
      * tracked changes on the git stash first, so the run isolates; `shared` runs
-     * this one run in the workspace root, knowingly. Returns the parked start for
-     * the caller to replay; null when nothing was parked.
+     * this one run in the workspace root, knowingly; `reread` does nothing to the
+     * tree, so the replay asks about it again (ADR-0053). Returns the parked start
+     * for the caller to replay; null when nothing was parked.
      */
-    continueBlocked(how: 'stash' | 'shared'): Promise<(() => Promise<void>) | null>;
+    continueBlocked(how: 'stash' | 'shared' | 'reread'): Promise<(() => Promise<void>) | null>;
     /**
      * The working directory of an attempt that may run in a worktree — which
      * attempts do is the attempt kind's to say (see `attemptKind.attemptCwd`):
@@ -797,6 +828,7 @@ declare class IsolationRunController {
      * settles. A git error is `failed`, never a throw.
      */
     integrate(task: Task, commit?: HandoffCommit): Promise<IsolationOutcome>;
+    private keepLandedOn;
     /** What a conflict repair's work shows (ADR-0015); git that cannot tell counts against it. */
     verifyRepair(task: Task): Promise<RepairEvidence>;
     /**
@@ -824,10 +856,12 @@ declare class IsolationRunController {
     awaitsMerge(taskId: string): boolean;
     /**
      * Look again for landed work the user has merged — by Merge all, or by hand
-     * with git. Resolves true when some was found.
+     * with git — or has taken back out. Resolves true when a mark changed.
      */
     refreshInHead(): Promise<boolean>;
-    /** Mark the run's landed work git finds in HEAD; true when some was found. */
+    /** Whether any landed work reads as merged: an answer git can take back, if the user takes the merge out. */
+    get readsMerged(): boolean;
+    /** Mark the run's landed work as git finds it now; true when a mark changed. */
     private findLanded;
     /** The run landed something and every landing is in the user's HEAD. */
     private allMerged;
@@ -858,6 +892,8 @@ declare class IsolationRunController {
     linkResolver(resolverId: string, conflictedId: string): void;
     /** The conflicted task a landed resolver was added for, forgotten as it is returned. */
     takeResolver(resolverId: string): string | undefined;
+    /** The tasks added to resolve this task's conflict: one, but for a plan saved before that was the rule (ADR-0015). */
+    resolversOf(conflictedId: string): string[];
     taskDiff(taskId: string, options: TaskDiffRead): Promise<TaskDiffResult>;
     reviewDiff(): Promise<string>;
     /**
@@ -869,6 +905,18 @@ declare class IsolationRunController {
      * HEAD somehow does not contain stays for the next run's sweep.
      */
     merge(): Promise<IsolationMergeResult>;
+    /** What git says of landed work a revert would take; see {@link IWorktreeIsolation.readLanded}. */
+    readLanded(taskIds: readonly string[]): Promise<LandedWork>;
+    /**
+     * Revert tasks' landings on the integration branches (ADR-0054). The record
+     * is reported changed once the tips are set and before the first commit,
+     * again as each commit is made, so a crash leaves it to tell them from
+     * anyone's, and once it settles. Bound to the run it was
+     * asked in: a plan loaded meanwhile has records of its own under these ids,
+     * and is saved without what this would write to that run's branches, so it
+     * stops the revert and leaves them as they were.
+     */
+    revert(taskIds: readonly string[], watch: Omit<RevertWatch, 'persist'>): Promise<IsolationRevertResult>;
     /**
      * Worktrees and task branches go; the integration branch and the record stay
      * for review and merge. Refused while a task of the run is still live.
@@ -895,6 +943,8 @@ declare class IsolationRunController {
     private discardMerged;
     /** Say what a removal kept back instead of deleting: where the work went, or which worktree stayed. */
     private report;
+    /** The branches the links' resolvers would merge have gone: the links go, and the scheduler is told of the tasks left. */
+    private endResolvers;
     /** The run goes from the plan; `merged` names it as {@link mergedRun} when everything it landed was merged. */
     private forget;
     private assess;
@@ -907,7 +957,8 @@ declare class IsolationRunController {
      * means a resumed plan's dependents must start from a tip that holds their
      * predecessors' work, and anything held — a kept attempt, a conflict, a
      * repair — is work the user may still want, which a fresh run's mint would
-     * delete. Only a run with no records at all is superseded.
+     * delete. Only a run with no records at all is superseded, and not one that
+     * reverted the tasks it had: a retry starts from its tip (ADR-0054).
      */
     private continuableRun;
     /**
@@ -1082,8 +1133,18 @@ declare class Landing {
         outcome: Promise<LandingOutcome>;
     } | null;
     private landConflicted;
-    /** The repair a conflicted task is owed next; null when repair is off, used up, or there is no isolated run to repair it in. */
+    /**
+     * The repair a conflicted task is owed next; null when repair is off, used
+     * up, or there is no isolated run to repair it in. A resolver takes the
+     * conflict instead: a conflict has one worker (ADR-0015).
+     */
     nextRepair(taskId: string): RepairAttempt | null;
+    /**
+     * The tasks in the plan still out to resolve this task's conflict. A skipped
+     * one has been given up, and a link to one that left the plan points at
+     * nothing, so either leaves the conflict free for another worker.
+     */
+    liveResolvers(taskId: string): Readonly<Task>[];
     /** What a repair is asked to do; read once `reopen` has recorded the tips it must bring in. */
     repairPrompt(task: Task): string;
     private hasUnlandedWork;
@@ -1185,7 +1246,9 @@ type TaskLogEvent =
 /**
  * A turn began by delivering `message`; `messageId` names it when it had been
  * queued, `forced` when it was force sent. `from` on this and the other
- * message events marks one Ordewell sent rather than the user.
+ * message events marks one Ordewell sent rather than the user. `startedAt`
+ * (ISO) is when it began, which a reload needs to date its open turn (#81);
+ * a log saved before it was kept has none.
  */
  | {
     type: 'turn_start';
@@ -1193,6 +1256,7 @@ type TaskLogEvent =
     messageId?: string;
     forced?: boolean;
     from?: TaskMessageFrom;
+    startedAt?: string;
 }
 /**
  * A turn began by running the runner's own command `/name args` (#66): the
@@ -1203,6 +1267,7 @@ type TaskLogEvent =
     name: string;
     args?: string;
     messageId?: string;
+    startedAt?: string;
 }
 /** What the running command printed, for one that runs without the model. */
  | {
@@ -1450,6 +1515,8 @@ interface TaskLogReader {
     patch?(taskId: string, attempt: number): Buffer | undefined;
 }
 
+/** Where a start stands against the user's Stop (ADR-0029): no longer current once one comes. */
+type Admitted = Pick<StartAdmission, 'current'>;
 type AttemptPhase = 'starting' | 'running' | 'integrating';
 /** Read-only view of a task's live attempt. */
 interface TaskAttemptSnapshot {
@@ -1475,9 +1542,10 @@ type StartWait =
     kind: 'started';
 }
 /**
- * A loop's check between rounds (ADR-0045 L3): the loop runs it again, as
- * round `round` of `maxRounds`, once its body has passed and landed;
- * `waiting` is the body that has not yet.
+ * A loop's check between rounds (ADR-0045 L3): it runs again, as round
+ * `round` of `maxRounds`, once its body has passed and landed; `waiting` is
+ * the body that has not yet. Whether anything will run it then is no part
+ * of the rule: a Stop or a reload leaves that to a start of it (L5).
  */
  | {
     kind: 'repeating';
@@ -1489,6 +1557,11 @@ type StartWait =
  | {
     kind: 'completing';
 }
+/** A task added to resolve its conflict has it: a conflict has one worker (ADR-0015). */
+ | {
+    kind: 'resolver';
+    resolver: string;
+}
 /** An AI task with no prompt yet, or a script task with no body to run: there is nothing to run. */
  | {
     kind: 'no-prompt';
@@ -1551,15 +1624,44 @@ type StartWait =
  * and goes past the whole gate and a planner turn's start hold. Queued behind
  * its dependencies, it starts later with nobody asking, so it waits for a
  * start hold as the scheduler's starts do, and goes past only the gate it was
- * confirmed past: `pastGate`.
+ * confirmed past: `pastGate`. `asScheduled` is one the start rule has already
+ * passed whole, carried back to the queue if it has to wait again.
  */
 type ForcedStart = {
     queued: false;
 } | {
     queued: true;
     pastGate: readonly string[];
+    asScheduled?: true;
 };
 
+type RevertRefusalReason = 'no-landing' | 'no-own-merge' | 'checked-out' | 'in-a-loop' | 'live-dependent' | 'in-branch' | 'git';
+interface RevertRefusal {
+    reason: RevertRefusalReason;
+    message: string;
+    /** `live-dependent`: the tasks in the way. */
+    tasks?: IsolationTaskRef[];
+    /** `in-branch`: what undoes the work there, newest first, for the user to run. */
+    commands?: RevertCommand[];
+}
+/** The tasks a revert would take, the one asked for first; `refusal` says why it may not go ahead, and with no landing there is nothing to take. */
+interface RevertScope {
+    taskIds: string[];
+    refusal?: RevertRefusal;
+}
+/** A task a preview lists; `dependent` is one that goes with the task the user chose, and `ref` how the plan calls it, a subtask's full path. */
+interface RevertPreviewTask extends IsolationRevertTask {
+    dependent: boolean;
+    ref?: string;
+}
+/** What a revert would do now, for a surface to confirm with the user before anything changes. */
+type TaskRevertPreview = {
+    revertible: true;
+    tasks: RevertPreviewTask[];
+} | ({
+    revertible: false;
+} & RevertRefusal);
+
 /** One reported window: what share of it is used, how long it is, and when it resets. */
 interface AccountLimitWindow {
     /** Which of a bucket's windows this is, in the order reported; only a label when the length is unknown. */
@@ -1629,6 +1731,178 @@ declare function accountLimitsText(snapshot: AccountLimitSnapshot): string | nul
  */
 declare function accountLimitsTitle(snapshot: AccountLimitSnapshot, time: (at: Date) => string): string;
 
+/**
+ * The bridge between "core needs an answer" and "a human somewhere is looking
+ * at a UI". Core cannot prompt: the human may be at a browser, a TUI, a CLI
+ * stream, or a VS Code webview, and on the web server they are on the far end
+ * of a socket. So the Session parks a promise here, announces the request
+ * through the normal broadcast seam, and every surface answers through the
+ * same `resolve(id, granted)` call.
+ *
+ * Timeouts are load-bearing rather than defensive: a planner turn that blocks
+ * forever on an unanswered prompt would hang the whole research loop with no
+ * visible cause. On expiry the request resolves to denied and the model gets a
+ * normal, actionable tool result. A task runner's request is the exception
+ * (ADR-0018, A1): the runner is parked on it rather than a research loop, and
+ * it waits for a person — or the supervisor — however long that takes.
+ */
+interface PendingApproval {
+    id: string;
+    request: ApprovalRequest;
+    createdAt: string;
+}
+interface PendingApprovalsOptions {
+    /** Denies and resolves after this long with no answer. Default 5 minutes. */
+    timeoutMs?: number;
+    /** Announce a new request to the surfaces. */
+    onRequest?: (pending: PendingApproval) => void;
+    /** Announce that a request is no longer actionable (answered or expired). */
+    onSettled?: (id: string, granted: boolean, settled: {
+        request: ApprovalRequest;
+        decision: ApprovalDecision;
+    }) => void;
+}
+interface AskOptions {
+    /**
+     * An id the caller already announced the request under. One still in use is
+     * refused — denied at once — rather than overwriting the request that has it.
+     */
+    id?: string;
+    /** Wait for an answer however long it takes. */
+    noTimeout?: boolean;
+    /**
+     * Given the answer as the request settles, before anything awaiting the
+     * promise runs: a caller about to tear down what asked (a runner being
+     * stopped) must deliver the answer before it goes.
+     */
+    onDecision?: (decision: ApprovalDecision) => void;
+}
+declare class PendingApprovals {
+    private readonly opts;
+    private readonly entries;
+    private readonly listeners;
+    constructor(opts?: PendingApprovalsOptions);
+    /** Hear each new request once it is announced — the supervisor wakes on a runner's (ADR-0029). */
+    listen(listener: (pending: PendingApproval) => void): () => void;
+    /** Park a request and return the promise the approval policy awaits. */
+    ask(request: ApprovalRequest, options?: AskOptions): Promise<boolean>;
+    /** Park a request whose answer is more than yes or no. */
+    decide(request: ApprovalRequest, options?: AskOptions): Promise<ApprovalDecision>;
+    /**
+     * Answer one request. Returns false when the id is unknown or already
+     * settled. "Allow for this task" on a request that did not offer it is a
+     * plain allow: no grant is made that the requester never proposed.
+     */
+    resolve(id: string, answer: ApprovalAnswer): boolean;
+    /** Everything still awaiting an answer — replayed to a surface that connects late. */
+    outstanding(): PendingApproval[];
+    /**
+     * Deny everything in flight, or only the requests `which` picks. Called on
+     * abort and on session reset.
+     */
+    clear(which?: (request: ApprovalRequest) => boolean, note?: string): void;
+}
+
+/**
+ * What an escalation waits on (ADR-0053). `approval`, `checkpoint`, `input`,
+ * `conflict`, `files-changed` and `usage-limit` are a task's wait; `failed` and
+ * `out-of-rounds` its end; `merge-gate`, `unapproved`, `on-hold`, `no-prompt`
+ * and `by-hand` what alone keeps a task from starting; `merge-all` and
+ * `blocked-run` are the run's own.
+ */
+type EscalationKind = 'approval' | 'checkpoint' | 'input' | 'conflict' | 'files-changed' | 'usage-limit' | 'failed' | 'out-of-rounds' | 'merge-gate' | 'unapproved' | 'on-hold' | 'no-prompt' | 'by-hand' | 'merge-all' | 'blocked-run';
+type EscalationOptionId = 'allow' | 'allow-for-task' | 'deny' | 'approve' | 'reject' | 'reply' | 'resume' | 'continue' | 'retry' | 'run' | 'force-start' | 'skip' | 'complete' | 'merge-all' | 'resolve-conflict' | 'start-resolver' | 'stash' | 'run-without-isolation';
+/** One answer the user may give: what the wait's own card or command offers. */
+interface EscalationOption {
+    id: EscalationOptionId;
+    label: string;
+    /** What this answer does with a note; absent when it takes none. */
+    note?: 'optional' | 'required';
+    /** The question a surface asks first, as it does on the card; the answer then carries the user's yes. */
+    confirm?: string;
+}
+/**
+ * One thing the run waits on a person for, derived and never stored
+ * (ADR-0053). No deadline and no default answer: answering for the user on a
+ * timer is a consent decision, which belongs to the mandate (#23).
+ */
+interface Escalation {
+    /**
+     * Kind, task and attempt, then the approval, what a merge gate waits to have
+     * merged, and how many of the attempt's waits ended before it; for Merge all,
+     * the run and the attempts it would merge. A later wait is another
+     * escalation, so a stale answer is told from a live one.
+     */
+    id: string;
+    kind: EscalationKind;
+    /** The task it belongs to, the link to its evidence; absent on the run's own. */
+    task?: {
+        id: string;
+        ref: string;
+        title: string;
+    };
+    /** The attempt it was raised in; absent before any ran. */
+    attempt?: number;
+    /** The runner request it answers, for `approval`. */
+    approval?: string;
+    /** The task out to resolve it, for a `conflict` nothing is starting that task for. */
+    resolver?: string;
+    reason: string;
+    options: EscalationOption[];
+}
+/** What the list reads of the run. */
+interface EscalationRun {
+    /** A full-plan run is scheduling, held, or ended on a failure a retry continues: only then, or in a carried loop, does a task that has not started wait on anyone, a reverted one apart. */
+    open: boolean;
+    /** Something could move a task on unasked, so the seam refuses a Mark complete (ADR-0029). */
+    advancing: boolean;
+    /** A Merge all is under way. */
+    merging: boolean;
+    /** Ordewell merges at gates by itself: the setting is on, and no merge has stopped it. */
+    autoMerges: boolean;
+    /** The run's close merges what landed by itself, so nobody has to; a Stop or a merge that stopped ends this, and the wait is real. */
+    mergesAtClose: boolean;
+    /** What Merge all would merge now. */
+    merge: RunMergeView | null;
+    /** The isolated run's id. */
+    id: string | null;
+    /** Which of the session's starts a dirty checkout turned away, when one waits on it; null when none does. */
+    blocked: number | null;
+}
+/** What the list is derived from: nothing here is kept for it. */
+interface EscalationInput {
+    /** The plan tree. */
+    tasks: readonly Task[];
+    /** Every task's start waits; see `planStartWaits`. */
+    waits: ReadonlyMap<string, readonly StartWait[]>;
+    approvals: readonly PendingApproval[];
+    /** The task's latest attempt, 0 before any ran. */
+    attempt: (task: Readonly<Task>) => number;
+    /** An attempt of the task is live, so a runner is there to hear an answer. */
+    live: (taskId: string) => boolean;
+    /** What the task's waiting checkpoint asks, whole. */
+    checkpoint: (taskId: string) => string | undefined;
+    /** Added since the user approved the plan, and left for them (ADR-0035). */
+    waitsForApproval: (taskId: string) => boolean;
+    /** Queued to start with no scheduler, once what holds it clears. */
+    startQueued: (taskId: string) => boolean;
+    /** Why the task is on hold. */
+    holdReason: (taskId: string) => string | null | undefined;
+    /** Something will run this check between rounds without being asked (ADR-0045 L5). */
+    loopRunsOn: (taskId: string) => boolean;
+    /** A loop carried on with no scheduler starts this task, so the run is open for it alone (ADR-0045 L5). */
+    carried: (taskId: string) => boolean;
+    run: EscalationRun;
+}
+/**
+ * Everything that will not move without a person (ADR-0053), in the order of
+ * what stops the most first: a run that cannot start, then the plan's tasks in
+ * order, then the work waiting to be merged. Pure and derived, as `planBlocks`
+ * and `startWaits` are: nothing is stored, so nothing has to be cleared, and it
+ * survives a reload as the waits it reads do.
+ */
+declare function escalations(input: EscalationInput): Escalation[];
+
 type SerializedTaskStatus = {
     id: string;
     /** The task's type, so a status-only surface can tag a script task (ADR-0035); absent from an older daemon. */
@@ -1692,6 +1966,8 @@ type SerializedTaskStatus = {
     waitsForApproval?: true;
     /** Why a task is held out of auto-scheduling, in the user's words; absent when it is not held. */
     holdReason?: string;
+    /** A loop's check between rounds that nothing will run, after a Stop or a reload (ADR-0045 L5). Absent for any other task. */
+    loopStranded?: true;
     /** Set only on a research task, so a stream of statuses alone can say which task is one (ADR-0037). */
     research?: true;
     /** The latest attempt's handoff, as the plan keeps it (ADR-0047); absent when the attempt left none. */
@@ -1859,6 +2135,8 @@ type SessionMessage =
  * digests the turn delivers, shown ahead of the prompt; `supervisor` marks a
  * wake-up turn, which no user message opened (ADR-0029). `forced`: the
  * prompt was force sent, and this turn replaces the one it stopped.
+ * `startedAt` (ISO) is when it began, which a surface counts its elapsed
+ * time from (#81); an older daemon sends none.
  */
  | {
     type: 'planner_turn_started';
@@ -1868,6 +2146,7 @@ type SessionMessage =
     wakeUps?: string[];
     supervisor?: true;
     forced?: true;
+    startedAt?: string;
 } | {
     type: 'planner_skill_loaded';
     turnId: string;
@@ -1978,12 +2257,26 @@ type SessionMessage =
     type: 'planner_compaction';
     compaction: PlannerCompaction;
     turnId?: string;
-} | {
+}
+/**
+ * A planner turn waits for the probe of installed coding agents (ADR-0009),
+ * or nothing does any longer. While `waiting`, no planner has heard of that
+ * turn, so a surface says so rather than that it is planning. It ends with
+ * the probe, whatever became of the turn: one stopped at the gate leaves it
+ * `true` for the next to wait under.
+ */
+ | {
+    type: 'planner_detection';
+    waiting: boolean;
+}
+/** `escalations`: what waits on a person now (ADR-0053), whole; absent from an older daemon. */
+ | {
     type: 'status_update';
     tasks: SerializedTaskStatus[];
     runMerge?: RunMergeView;
     usage?: PlanUsage;
     activity?: RunActivity;
+    escalations?: Escalation[];
 } | {
     type: 'review_needed';
     tasks: SerializedTask[];
@@ -2097,7 +2390,7 @@ type PlanSnapshot = {
     plan: SurfacePlan | SurfacePlanState;
 };
 /** What only the status stream says about a task; a plan refresh keeps these as they were. */
-type RunTaskStatus = Partial<Pick<SerializedTaskStatus, 'verdict' | 'idleSince' | 'completionReceived' | 'attaching' | 'isolation' | 'checkpoint' | 'queued' | 'continuable' | 'awaitingApproval' | 'mergeGate' | 'forcedPastGate' | 'waitsForApproval' | 'holdReason' | 'handoff' | 'attempted'>>;
+type RunTaskStatus = Partial<Pick<SerializedTaskStatus, 'verdict' | 'idleSince' | 'completionReceived' | 'attaching' | 'isolation' | 'checkpoint' | 'queued' | 'continuable' | 'awaitingApproval' | 'mergeGate' | 'forcedPastGate' | 'waitsForApproval' | 'holdReason' | 'loopStranded' | 'handoff' | 'attempted'>>;
 /** A task in the run view: the plan's fields, then the status stream's. */
 type RunTask = Omit<SerializedTask, 'subtasks'> & RunTaskStatus & {
     subtasks: RunTask[];
@@ -2144,6 +2437,8 @@ interface RunView {
     mergeResult: IsolationMergeResult | null;
     /** What the scheduler is doing with the plan, as {@link RunActivity}. */
     activity?: RunActivity;
+    /** What will not move without a person (ADR-0053), as the newest status update said; absent from an older daemon's snapshot. */
+    escalations?: Escalation[];
 }
 type RunInput = SessionMessage | PlanSnapshot;
 /**
@@ -2159,7 +2454,7 @@ type SessionNotice = {
 };
 type SessionBroadcaster = (msg: SessionMessage) => void;
 declare function serializeTask(t: SurfaceTask): SerializedTask;
-declare function serializeTaskStatus(t: Task, idleSince?: string | null, isolation?: TaskIsolation | null, queued?: readonly QueuedTaskMessage[], awaitingApproval?: number, mergeGate?: readonly string[], checkpoint?: string, waitsForApproval?: boolean, holdReason?: string | null, completionReceived?: Verdict['reported'] | null, attaching?: 1 | 2 | null): SerializedTaskStatus;
+declare function serializeTaskStatus(t: Task, idleSince?: string | null, isolation?: TaskIsolation | null, queued?: readonly QueuedTaskMessage[], awaitingApproval?: number, mergeGate?: readonly string[], checkpoint?: string, waitsForApproval?: boolean, holdReason?: string | null, completionReceived?: Verdict['reported'] | null, attaching?: 1 | 2 | null, loopStranded?: boolean): SerializedTaskStatus;
 /** The one place a plan's skill bodies come off before it leaves the session: every wire path that carries plan state goes through here. */
 declare function surfacePlan({ queuedMessages: _carriedOverAtLoad, ...plan }: LegacyPlanState): SurfacePlan;
 declare function surfacePlanState(state: PlanState): SurfacePlanState;
@@ -2249,9 +2544,11 @@ declare class SessionHeldError extends Error {
 interface SessionLease {
     /**
      * Hold `sessionId`'s lease in `workspace`, letting go of the one held before
-     * only once this one is held. Throws {@link SessionHeldError}.
+     * only once this one is held. Throws {@link SessionHeldError}. `commit` runs
+     * holding both: when it throws, the one held before is still held, and a
+     * lease this claim took is let go.
      */
-    claim(sessionId: string, workspace: string): void;
+    claim(sessionId: string, workspace: string, commit?: () => void): void;
     /**
      * Null while this Session holds `sessionId`'s lease, claiming it when no
      * live host holds it; otherwise who holds it. A lease another host took from
@@ -2332,7 +2629,7 @@ declare class HostedLease implements SessionLease {
     workspace: string;
     private lostLease;
     constructor(host: LeaseHost, onLost: (held: SessionHeld) => void);
-    claim(sessionId: string, workspace: string): void;
+    claim(sessionId: string, workspace: string, commit?: () => void): void;
     hold(sessionId: string, workspace: string): SessionHeld | null;
     release(): void;
     /** @internal Another host took `file`'s lease from this one. */
@@ -2354,10 +2651,12 @@ type AutoMergeTrigger = {
 };
 /**
  * Who opened a run (ADR-0029): a call the user made, or one made for them; a
- * call of the supervisor's own; or a usage-limit reset resuming what it paused.
- * Only the user's starts a run's supervision afresh.
+ * call of the supervisor's own, or a subplanner's, which has no user to make
+ * one for (ADR-0056 M6); a usage-limit reset resuming what it paused; or a loop
+ * carried on with no scheduler (ADR-0045 L5). Only the user's starts a run's
+ * supervision afresh.
  */
-type RunOrigin = 'user' | 'supervisor' | 'limit-reset';
+type RunOrigin = 'user' | 'supervisor' | 'limit-reset' | 'loop';
 /** What the scheduler reads of the open run's settings, at each decision it makes from them. */
 type SchedulerRunSettings = Pick<RunSettings, 'mergeAtGatesAutomatically'>;
 /**
@@ -2515,6 +2814,8 @@ interface TaskOrchestratorDeps {
      * owns it, and the scheduler starts nothing outside it.
      */
     isApproved: (taskId: string) => boolean;
+    /** Read beside the run's setting at each automatic merge, which passes no command (ADR-0056 M6). */
+    mayMergeUnasked: () => boolean;
     /** A read-only attempt's shell (ADR-0046); absent, its runner is given no `run_command`. */
     taskShell?: (site: TaskShellSite) => TaskShell | undefined;
     /** The session's web fetcher for one read-only attempt (ADR-0046); absent, its `fetch` and `web_search` are not available. */
@@ -2556,6 +2857,8 @@ interface TaskOrchestratorOptions {
     plannedWith?: () => boolean;
     /** Every task is approved unless a Session supplies its record: an orchestrator on its own has no user to ask. */
     isApproved?: (taskId: string) => boolean;
+    /** Whether this node's mandate lets an automatic merge run; true unless set. */
+    mayMergeUnasked?: () => boolean;
     taskShell?: (site: TaskShellSite) => TaskShell | undefined;
     taskWebFetcher?: (task: string) => IWebFetcher | undefined;
     keepPatch?: (taskId: string, attempt: number, patch: Buffer) => string;
@@ -2589,6 +2892,10 @@ declare class TaskOrchestrator {
     private runState;
     /** Planner turns in flight that new starts wait for (ADR-0029); running attempts carry on. */
     private startHolds;
+    /** The judgement a {@link judgingOnce} read shares, while one runs. */
+    private judgement;
+    /** The {@link revertReach} of each revert under way: unlike a hold, it stops a start admitted before the revert too. */
+    private readonly reverting;
     /** Bumped by the user's Stop: a start admitted under an older generation never takes its claim. */
     private stopGeneration;
     /** Starts admitted and not yet claimed or let go; see {@link StartAdmission}. */
@@ -2625,6 +2932,16 @@ declare class TaskOrchestrator {
     private queuedStarts;
     /** Conflict repairs owed with every slot taken and no scheduler to claim them: a freed slot starts them. */
     private owedRepairs;
+    /**
+     * The checks whose loop goes on with no scheduler: each failed a round in a
+     * run the scheduler was not driving, so nothing else would start what it
+     * owes (ADR-0045 L5). Held here and not on the plan, because a Stop ends it
+     * and a reload does not bring it back; an edit does neither. A loop stopped
+     * by its body stays here, so a retry of that task resumes it (L7).
+     */
+    private readonly carriedLoops;
+    /** What was last said of a carried loop's approvals, so it is said once. */
+    private loopNotice;
     /**
      * Tasks Mark complete is landing after it ended their attempt, or that
      * their conflict resolver is landing, and that landing: in progress with
@@ -2649,6 +2966,7 @@ declare class TaskOrchestrator {
     private previousRounds;
     private runSettings;
     private isApproved;
+    private mayMergeUnasked;
     constructor(deps: TaskOrchestratorDeps);
     /**
      * The composition root: resolves every optional collaborator and wires the
@@ -2716,6 +3034,10 @@ declare class TaskOrchestrator {
     get isReviewApproved(): boolean;
     /** The scheduler is driving the plan: ready tasks start on their own as slots free. Narrower than {@link isRunning}. */
     get isScheduling(): boolean;
+    /** A scheduled run, driving the plan or held by a usage limit that gives it back: a hold never closes one. */
+    get scheduledRun(): boolean;
+    /** A usage limit holds the run, whatever it goes back to at the reset. */
+    get runHeld(): boolean;
     /**
      * A full-plan run with nothing starting that something still resumes: a
      * usage limit's reset, or a retry of a failed task its blocked tasks wait on.
@@ -2726,6 +3048,8 @@ declare class TaskOrchestrator {
     /** Task id → session id of every attempt whose runner is up; a spawn in flight has no session yet. */
     get activeSessionMap(): Map<string, string>;
     getAttempt(taskId: string): TaskAttemptSnapshot | undefined;
+    /** The number of the task's latest attempt, live or ended; 0 before any ran. */
+    latestAttempt(task: Readonly<Task>): number;
     /** A planner turn holds new starts: what is ready starts when it releases them. */
     get startsHeld(): boolean;
     /**
@@ -2745,11 +3069,19 @@ declare class TaskOrchestrator {
      * Something can still start that nobody has to ask for again: a start
      * admitted and not yet claimed, a force start queued behind its
      * dependencies, a conflict repair owed a slot or the end of a start hold,
-     * a task that resumes on its own at its usage limit's reset, or a start a
-     * dirty checkout parked for Stash and continue to replay. A Stop is owed to
-     * it, whether or not anything runs.
+     * a task that resumes on its own at its usage limit's reset, a start a
+     * dirty checkout parked for Stash and continue to replay, or a loop carried
+     * on with no scheduler. A Stop is owed to it, whether or not anything runs.
+     * A carried loop a body task stopped starts nothing, so it is not here: see
+     * {@link loopCarried}.
      */
     get startsPending(): boolean;
+    /**
+     * A loop is carried on, one a body task stopped included. Nothing of that
+     * one starts by itself, so nothing here moves a task on, but a retry that
+     * passes would resume it: a Stop is owed to it too (ADR-0045 L7).
+     */
+    get loopCarried(): boolean;
     /**
      * The plan's activity as one word for every surface: a start on its way,
      * work running, a scheduler driving the plan, or a run that resumes by
@@ -2769,7 +3101,9 @@ declare class TaskOrchestrator {
      */
     get advancesOnItsOwn(): boolean;
     /** A start admitted now that nothing has to count as live work: one that claims before it awaits, or follows on from one that did. */
-    private admittedNow;
+    admittedNow(): Admitted;
+    /** The user's Stop found nothing to stop: it still withdraws every start admitted before it, one no live work counts included (ADR-0029). */
+    stopAsked(): void;
     /** Run `work`, which awaits before it claims, under an admission it holds throughout and claims under. */
     private whileAdmitted;
     /**
@@ -2787,6 +3121,13 @@ declare class TaskOrchestrator {
      * over as before.
      */
     private closeRun;
+    /**
+     * Whether closing the run merges what landed, with nobody asked. The run
+     * says it has ended before it closes, and a list read in between must not
+     * name a Merge all it is about to do itself (ADR-0053). A Stop takes the run
+     * out of isolating and a merge that stopped blocks this, so neither wait is hidden.
+     */
+    get mergesAtClose(): boolean;
     /**
      * The run as a surface offers Merge all mid-run (ADR-0020): what has landed
      * and is not merged, and whether the run is paused at its gates with nothing
@@ -2809,9 +3150,41 @@ declare class TaskOrchestrator {
      * Takes the task, not its id: the one the command seam located.
      */
     startWaits(task: Readonly<Task>, forced?: ForcedStart): StartWait[];
+    /** Every task's {@link startWaits}, the plan judged once. */
+    planStartWaits(): Map<string, StartWait[]>;
+    /**
+     * Run `read`, a synchronous read of the plan, on one judgement of it: what a
+     * read asks task by task would otherwise judge the whole plan per task.
+     * Nothing can change the plan inside it, so no answer can be stale.
+     */
+    judgingOnce<T>(read: () => T): T;
     private startRule;
+    /**
+     * Why no resolver may be added to this task's conflict now, or null: a
+     * conflict has one worker (ADR-0015), so a repair or a resolver that has it
+     * keeps it. The words are for whoever asked, since a surface may still offer
+     * the action from a status update it has not yet replaced.
+     */
+    resolverRefusal(taskId: string): string | null;
+    /** What the conflict repair this task is owed waits for; null when no repair will start by itself. */
+    repairWait(taskId: string): RepairWait | null;
+    /** A usage limit keeps this task from starting by itself: the hold on the run, or its own runner's limit with no reset to wait for. */
+    private onUsageLimit;
+    /** Where a task's isolated work stands, and who has its conflict: the record says the first, the scheduler the second. */
+    taskIsolation(taskId: string): TaskIsolation | null;
+    /** Each task's isolation mark and the run's handoff, as {@link taskIsolation} reads them. */
+    isolationView(): IsolationView | null;
+    private withConflictWorker;
+    /**
+     * A repair will start by itself: the task is not started, it has one left,
+     * and something will claim it, the scheduler or {@link owedRepairs}. Nothing
+     * saves this: a reload or a Stop leaves the conflict waiting on the user.
+     */
+    private owesRepair;
     /** The failed tasks a task not started yet waits on, through its dependencies (ADR-0034); empty when it is not blocked. */
     getBlockedBy(taskId: string): string[];
+    /** Throws what {@link loadPlan} would, for a caller with work of its own to do before it loads. */
+    assertLoadable(tasks: readonly Task[], planRunners?: RunnerId[]): void;
     /**
      * `edited`: the plan is the last one edited, not a new one. Only a Stop
      * withdraws a queued start (ADR-0035), so one of a task the edit keeps
@@ -2825,8 +3198,9 @@ declare class TaskOrchestrator {
      * reload would clear the holds and the review approval, so a task the user
      * cancelled would be re-armed by the tick that follows, and a retry after
      * the edit would run the failed task alone, its failure lost. Otherwise it
-     * is the plan the next run starts from, with what waits on a usage-limit
-     * reset still waiting: an edit between runs is not the user starting over.
+     * is the plan the next run starts from, with a failed task still failed and
+     * what waits on the user still waiting: an edit between runs is not the user
+     * starting over.
      */
     adoptEdit(tasks: readonly Task[], planRunners: RunnerId[]): void;
     /**
@@ -2841,37 +3215,51 @@ declare class TaskOrchestrator {
      * input it waits at — adopting the snapshot's "pending" would offer the
      * scheduler work a runner is already doing.
      *
-     * A failed task stays failed, unlike a plan load's fresh chance: an edit is
-     * not a retry, and the tasks it blocks wait for that retry (ADR-0034).
+     * A failed task stays failed: an edit is not a retry, and the tasks it blocks
+     * wait for that retry (ADR-0034). One the edit made manual has no retry to wait for.
      */
     reconcilePlan(newTasks: readonly Task[], planRunners?: RunnerId[]): void;
     /**
      * An edit landed on the plan — a planner's task ops through
      * {@link reconcilePlan}, or the user's direct edit through the PlanEditor.
-     * One that leaves a loop's check out of rounds ends the loop (ADR-0045 L6):
-     * what of its body has not run will not run, and, while the run is under
-     * way, the check settles once more so the supervisor hears the end. Nothing
-     * else notices such an edit: the check settled when it failed a round, and
-     * no round will run it again.
+     * A task it made manual is the manual task it now is (ADR-0053), a runner
+     * still at a question apart. One that leaves a loop's check out of rounds
+     * ends the loop (ADR-0045 L6): what of its body has not run will not run,
+     * and, while the run is under way, the check settles once more so the
+     * supervisor hears the end. Nothing else notices such an edit: the check
+     * settled when it failed a round, and no round will run it again.
      */
     planEdited(before: readonly Task[]): void;
     /**
-     * Begin the full-plan run afresh, as Execute does with nothing at work.
-     * Whatever an earlier run left goes: its state, even held or armed with
-     * nothing live, which {@link start} would take as a run already under way;
-     * its scheduled resumes and execution log; and, as the plan is loaded over
+     * Begin the full-plan run afresh, as Execute does with no open run to join.
+     * Whatever an earlier run left goes: its state, which {@link start} would
+     * take as a run already under way; its scheduled resumes and execution log;
+     * and, as the plan is loaded over
      * itself, its retry counts, holds, loop rounds and review approval. Every
      * task not done is ready to run again, and the scheduler starts it; a plan
-     * with nothing left to run ends at once, and the scheduler says so.
+     * with nothing left to run ends at once, and the scheduler says so, but for
+     * `keepFailed`: failures nobody asked this run to try again (ADR-0030).
      */
-    beginRun(origin: RunOrigin): Promise<void>;
+    beginRun(origin: RunOrigin, keepFailed?: ReadonlySet<string>): Promise<void>;
     /**
      * Take the plan into the run under way (#95), whose tasks were approved
      * first: a scheduled run starts them as their dependencies finish, and one
      * the scheduler was not driving — tasks started on their own — becomes the
-     * plan's run, as Execute would make it.
+     * plan's run, as Execute would make it. A hold starts nothing either way:
+     * the plan's run is what its reset gives back (ADR-0018 U1). A start a dirty
+     * checkout parked in a scheduled run is replayed, which reads the checkout
+     * again; a new run would take back the run's failures (ADR-0053).
      */
     joinRun(origin: RunOrigin): Promise<void>;
+    private joinHold;
+    /**
+     * The user's Execute takes in work the scheduler was not driving: it becomes
+     * the plan's run, so what failed gets the fresh chance Execute gives
+     * (ADR-0053). A scheduled run keeps its failures, which a retry continues
+     * (ADR-0034), and Execute only approves what waits in it: a hold that gives
+     * one back is that run still.
+     */
+    readyFailed(): void;
     /** Start the full-plan run, or continue one that is held or ended on a failure. */
     start(origin?: RunOrigin): Promise<void>;
     /**
@@ -2881,6 +3269,18 @@ declare class TaskOrchestrator {
      * for meanwhile.
      */
     stop(reason?: 'user' | 'restart'): void;
+    /**
+     * Nothing claims a repair once the run has stopped, so what was owed one is
+     * a conflict waiting on the user, listed with its options, not a task that
+     * reads as never started.
+     */
+    private withdrawRepairs;
+    /**
+     * A force start behind a dependency lifted a reverted task's hold for that
+     * start alone, in the queue or left to the scheduler. With the start
+     * withdrawn, the task stays what the user took back (ADR-0054).
+     */
+    private withdrawQueuedStarts;
     private chosenHoldsNow;
     private restoreHolds;
     private releaseUnchosenHolds;
@@ -2942,13 +3342,26 @@ declare class TaskOrchestrator {
      * Work that did not land waits on the user — it never fails the task or
      * blocks its dependents — unless its conflict is owed a repair, which takes
      * the slot the ending attempt freed and never one more than the run allows.
-     * A planner turn's start hold holds it as it holds any new spawn (ADR-0029).
-     * The repair follows on from the start whose work it repairs: a Stop since
-     * that was admitted withdraws it.
+     * A planner turn's start hold holds it as it holds any new spawn (ADR-0029),
+     * and a usage limit does too: `reopen` spends a repair, so one the runner
+     * would refuse is not tried. The repair follows on from the start whose work
+     * it repairs: a Stop since that was admitted withdraws it.
      */
     private settleUnlanded;
     /** Start the repairs {@link settleUnlanded} left owed, as slots and any start hold allow. */
     private startOwedRepairs;
+    /**
+     * A conflict ended some other way than through its resolver: the task
+     * landed, was retried or skipped, or left the plan. The merge the resolver
+     * was added for is no longer needed, so it goes with its link: skipped,
+     * with why, and never started (ADR-0015).
+     */
+    private retireResolvers;
+    private retireResolver;
+    /** A planner's remove reaches no {@link releaseTask}: what it took out of the plan since `before` ends its conflicts here. */
+    private retireResolversLeft;
+    /** A control that would end a conflict waits for the resolver at work on it: a conflict has one worker (ADR-0015). */
+    private refuseBesideResolver;
     private landResolved;
     /**
      * Hold a task for as long as `landing` is merging its worktree. Its end lets
@@ -2959,6 +3372,10 @@ declare class TaskOrchestrator {
     getReadyTasks(): Task[];
     private readiness;
     private mergesAutomatically;
+    /** A Merge all is under way. */
+    get isMerging(): boolean;
+    /** A gate reached now is merged with nobody asked: the setting is on, and no merge has stopped it. */
+    get mergesAtGates(): boolean;
     /**
      * The user changed the run settings under an open run (ADR-0030). The
      * scheduler reads them at each decision it makes from them, so a merge gate
@@ -2993,6 +3410,7 @@ declare class TaskOrchestrator {
      * Cancel a running (or scheduled) task: kill its session and return it to
      * 'pending' — "not executed". The task is put on hold so the scheduler
      * doesn't immediately restart it; Retry / Force Start release the hold.
+     * A repair, running or owed a start, leaves its conflict waiting instead.
      *
      * The attempt's worktree is kept, as a stopped or failed one is: a runner is
      * often cancelled because it looked stuck after doing the work, and Mark
@@ -3028,6 +3446,33 @@ declare class TaskOrchestrator {
      * to waiting on their own, because the scheduler gates on `isCompleted`.
      */
     markTaskIncomplete(taskId: string): Promise<void>;
+    /**
+     * What reverting a task would take, and what stands in its way, as far as
+     * the plan can say (ADR-0054); {@link revertPreview} and the revert itself
+     * ask git the rest.
+     */
+    revertScope(taskId: string): RevertScope;
+    /** What a revert of the task would do now: the tasks, newest landing first, or why it would not go ahead. */
+    revertPreview(taskId: string): Promise<TaskRevertPreview>;
+    /**
+     * Revert the task's landed work, with its landed dependents, on the
+     * integration branches (ADR-0054). No new start while it waits for its
+     * turn and works: one that took its claim now would be cut from a tip about
+     * to lose what it depends on, so the claim of anything depending on the work
+     * is refused too, a start admitted before the revert with it. What it finds
+     * in the way there is judged again: a Mark complete landing a dependent is
+     * live like any other. Tasks not depending on it keep running.
+     */
+    revertTask(taskId: string): Promise<IsolationRevertResult>;
+    private revertRefusalNow;
+    /**
+     * Each reverted task goes back to not started, held like a stopped one so
+     * the scheduler does not run it again, and starts over when retried: from
+     * the current tip, which no longer holds its work. Its completion goes as
+     * Mark not done takes one back; the logs of its attempts stay. A conflict it
+     * held is over, so a resolver out to it goes too (ADR-0015).
+     */
+    private takeBack;
     /**
      * Skip: end a task as `skipped`, with no verdict and nothing of its work
      * landed. Its worktree is kept, as a failed attempt's is, so the user can
@@ -3044,8 +3489,10 @@ declare class TaskOrchestrator {
      * the task ended in rather than a fresh one given its prompt again. The
      * worktree keeps the same path, where the runner keeps its sessions, and
      * restores the previous work so that session's memory matches its files.
+     * `revives` is {@link claimRefusal}'s, read as the start is asked for: a dirty
+     * tree's replay carries the first answer, not one read after a skip.
      */
-    continueTask(taskId: string, message: string, origin?: RunOrigin): Promise<void>;
+    continueTask(taskId: string, message: string, origin?: RunOrigin, revives?: boolean): Promise<void>;
     /**
      * Keep a task paused on its runner's usage limit from resuming on its own:
      * it waits for a manual retry, as one whose reset time could not be read
@@ -3108,9 +3555,9 @@ declare class TaskOrchestrator {
      * Reuses the scheduler's own claim so a force-started task gets the same
      * augmented prompt, session tracking, and exit handling — callers must not
      * re-spawn the runner themselves. No-op if the task is unknown, a user
-     * task, or already running.
+     * task, or already running. `revives` is as on {@link continueTask}.
      */
-    forceStartTask(taskId: string, origin?: RunOrigin): Promise<string | undefined>;
+    forceStartTask(taskId: string, origin?: RunOrigin, revives?: boolean): Promise<string | undefined>;
     /**
      * Start an approved task once its merge gate opens, never past it: a script
      * task `run_script` added behind work not merged into the user's branch yet
@@ -3119,6 +3566,17 @@ declare class TaskOrchestrator {
      * so it starts once Merge all has merged that work, and a Stop withdraws it.
      */
     startAtGate(taskId: string): void;
+    /** A start of this task waits in the queue, and starts with nobody asked once what holds it clears. */
+    startQueuedFor(taskId: string): boolean;
+    /**
+     * Start a task the user's own act asked for, under the one start rule and
+     * past none of it (ADR-0015). A scheduler driving the run claims it as it
+     * would any task; otherwise it waits with the queued starts for a slot, a
+     * start hold or a usage limit, says what holds it, and a Stop withdraws it.
+     * A conflict repair is started the same way, and this is what a resolver
+     * added outside a run has in place of one.
+     */
+    startWhenAllowed(taskId: string): void;
     /**
      * A forced start, from its run opening to its claim. It is judged again once
      * the run has opened, against the task as it stands then, which is what
@@ -3159,6 +3617,9 @@ declare class TaskOrchestrator {
     private holdsQueued;
     private slotsFull;
     private sayQueuedAtGate;
+    /** A start asked for under the whole rule that the rule holds back, in words the user can act on; a turn's hold ends by itself. */
+    private sayQueuedHeld;
+    private sayOnce;
     private refuseOpsDuringMerge;
     /**
      * A force start passes a merge gate (ADR-0020), and the surface confirmed it
@@ -3172,6 +3633,8 @@ declare class TaskOrchestrator {
     isAnyFailed(): boolean;
     approveReview(origin?: RunOrigin): Promise<void>;
     tick(): Promise<void>;
+    /** One of a tick's starters: takes the next of `waiting` as each start it made has attached. */
+    private startReady;
     /**
      * The one step that decides, with nothing at work and nothing the scheduler
      * can start, whether the run goes on, is held, waits on the user or is over
@@ -3179,9 +3642,11 @@ declare class TaskOrchestrator {
      * only an end emits it. A run the scheduler is not driving — tasks started
      * on their own — ends on a verdict; a cancel, Mark complete or failed spawn
      * just closes it, so the next run decides its own mode rather than inherit
-     * this one's.
+     * this one's. A loop carried on outside a scheduled run holds that run open
+     * as a scheduled one is held, on whatever the start rule waits for.
      */
     private settleRun;
+    private waitOnUser;
     /**
      * A loop's check failed (ADR-0045). With `failed` evidence and rounds left,
      * a round starts: its body runs again as new attempts, each from the
@@ -3189,7 +3654,9 @@ declare class TaskOrchestrator {
      * the failure is the round's, not the task's. Approval is not spent by a
      * run, so the plan's approval of the body covers every round. Out of
      * rounds, the body still to run will not run. A body task the user skipped
-     * has stopped the loop (L7): no round starts, and the skip stands.
+     * has stopped the loop (L7): no round starts, and the skip stands. One they
+     * reverted keeps its hold, which a round takes as any start does (L5, ADR-0054):
+     * the rest of the body runs, and the loop waits for them to say.
      */
     private startRound;
     /**
@@ -3205,6 +3672,39 @@ declare class TaskOrchestrator {
      * complete, a reload in between — resumes the loop alike.
      */
     private repeatChecks;
+    private repeatCheck;
+    /**
+     * Something will run this check between rounds without being asked: a
+     * scheduler, the one a reset gives back, or its loop carried on (ADR-0045
+     * L5). What the seam reads before it says so to anyone.
+     */
+    loopRunsOn(checkId: string): boolean;
+    /** A start of this task would be its loop's next round: between rounds, its body landed, and nothing else will run it. */
+    private ownsNextRound;
+    /** A check between rounds that nothing will run: it waits on a person, its failure no longer one its loop answers (ADR-0045 L5, ADR-0053). */
+    loopStranded(taskId: string): boolean;
+    /** A tick starts something: the scheduler the plan, or the loops carried on, their tasks alone. */
+    private get startsOnTick();
+    /**
+     * The carried loops with work owed now: a check between rounds whose loop
+     * goes on, or a round waiting to start. None under a scheduler, which owes
+     * them itself, or while a usage limit holds the run, which starts nothing.
+     * One a body task stopped is not here until that task passes (L7).
+     */
+    private loopsCarriedOn;
+    /**
+     * The run that carried them is over, by a Stop or by what gives the run up
+     * or clears it up: a retry of a body task that passes runs that task alone.
+     */
+    private endCarriedLoops;
+    /** What a tick may start with no scheduler: the loops carried on, and nothing that depends on them. */
+    carriedTasks(): Set<string>;
+    /**
+     * A task of a carried loop outside the user's approval record waits as any
+     * does (ADR-0045, Consent). Said here, once, as well as listed: a run they
+     * started one task of says nothing else of why the loop's next step does not come.
+     */
+    private sayUnapprovedInLoop;
     /** Skipped work is not completed work, so a run with any says so rather than that everything completed. */
     private sayFinished;
     /** How a run that ended on failures ends: what it finished, what failed, and what that blocks. */
@@ -3219,9 +3719,14 @@ declare class TaskOrchestrator {
     /**
      * Why a start may not take its claim now, or null when it may: a Stop came
      * since it was admitted (ADR-0029), the task left the plan or is being
-     * marked complete, it is outside the user's approval record (ADR-0035), or
-     * every slot is taken. Read in the same synchronous step as the claim it
-     * guards, so nothing can change in between.
+     * marked complete, a resolver has its conflict, so a start of it would be a
+     * second worker on it (ADR-0015), a revert is taking back work it depends on
+     * or skipped it since (ADR-0054), it
+     * is outside the user's approval record (ADR-0035), or every slot is taken.
+     * Read in the same synchronous step as the claim it
+     * guards, so nothing can change in between. `revives` is a start asked of a
+     * task already skipped, as a force start or a continue may be: only that runs
+     * one again. A retry has made it pending by the time it claims.
      */
     private claimRefusal;
     /** An explicit start's refusal, before it changes anything: its caller's answer, as a {@link TaskControlError}. */
@@ -3244,10 +3749,196 @@ declare class TaskOrchestrator {
     /**
      * Replay the start a dirty tree turned away. `stash` puts the user's tracked
      * changes on the git stash first, so the run isolates; `shared` runs this one
-     * run in the workspace root, knowingly.
+     * run in the workspace root, knowingly; `reread` reads the tree again, which
+     * may turn the start away again.
      */
-    continueBlockedRun(how: 'stash' | 'shared'): Promise<void>;
+    continueBlockedRun(how: 'stash' | 'shared' | 'reread'): Promise<void>;
+}
+
+/**
+ * The effect allowlist (ADR-0035): the user's standing approval for named
+ * effects, beside the planner allowlist, which names reads. It pre-approves a
+ * script task whose `commands` are all covered; it never covers a `script`
+ * body, whose shell text no rule can be matched against.
+ *
+ * A rule is matched against the whole command, every word in order and flags
+ * included, because an effect's flags change what it does: `git push origin
+ * feature/*` covers `git push origin feature/login`, never the same push with
+ * `--force`. `*` stands for one word, or inside a word for any run of
+ * characters, as in the planner allowlist, except that it never stands for
+ * what changes the effect: a flag (`--force`, and `/force` on Windows), a
+ * refspec's force or delete (`+main`, `:main`), or a `:` outside a URL
+ * (`feature/x:main`, which pushes to `main`). The rule writes any of those
+ * itself. A rule spells out its operation before any `*`, so
+ * `az webapp config * set` is no rule at all.
+ *
+ * Exclusions are the planner allowlist's `!` entries, with any `!` entry
+ * written here; an exclusion wins. A command exclusion is matched as the
+ * planner allowlist matches it; a path or URL exclusion holds for an argument
+ * that names an absolute path or URL it covers, whole or after a `=`, `@`,
+ * `:` or `,` or a short flag (`--url=…`, `-d @…`). A relative path is not
+ * resolved, since the body does not say where it runs. A program named by its
+ * path is a file the repository ships (ADR-0026), so it is never covered.
+ * There are no built-in rules: a default would pre-approve an effect the user
+ * never chose.
+ */
+interface EffectRule {
+    text: string;
+    binary: string;
+    words: RuleWord[];
+}
+interface EffectRules {
+    rules: EffectRule[];
+    exclusions: PlannerAllowlist;
+    platform: NodeJS.Platform;
+    /** The entries that are no rule, each with the warning that says why it is ignored. */
+    ignored: {
+        rule: string;
+        warning: string;
+    }[];
 }
+/**
+ * `entries` are the effect allowlist's; `plannerEntries` the planner allowlist
+ * in force, whose `!` entries hold here too; `platform` the one the commands
+ * run on, which decides how a flag is spelled and how a path resolves.
+ */
+declare function parseEffectAllowlist(entries: readonly string[], plannerEntries?: readonly string[], platform?: NodeJS.Platform): EffectRules;
+/**
+ * The rules, by name, that cover every command of a `commands` body, or null
+ * when one command is not covered, an exclusion holds for one, or the body is
+ * a `script`.
+ */
+declare function effectRuleFor(list: EffectRules, body: ScriptBody): string | null;
+
+/**
+ * The mandate (ADR-0056): what a node may do without a person, and within what
+ * limits. The root's is derived on each read from today's settings and never
+ * saved; a child's is one pure function of its parent's and its request, which
+ * can only narrow what the parent may hand on. Authority only: capability stays
+ * at the boundary a session runs in, and a prompt enforces nothing.
+ */
+declare const GRANTS: readonly ["observe", "steer", "control", "replan", "approve", "delegate", "effect", "research", "merge"];
+/** Each is a set of things a node may do unasked (M2). */
+type Grant = (typeof GRANTS)[number];
+/** What a mandate could not finish without: a child holds these unasked, and `narrow` refuses one that would lack any (M2). */
+declare const FLOOR_GRANTS: readonly Grant[];
+/** The shape of a tree, by ADR-0055 D19: refused past the hard cap, never dropped. */
+declare const SHAPE_LIMITS: {
+    readonly depth: {
+        readonly default: 2;
+        readonly hard: 4;
+    };
+    readonly delegatedTasks: {
+        readonly default: 8;
+        readonly hard: 30;
+    };
+    readonly tasksPerPlan: {
+        readonly default: 30;
+        readonly hard: 100;
+    };
+};
+interface MandateLimits {
+    /** The node's token budget; the root's is the tree's, from the delegation setting (M3, M5). */
+    tokens: number;
+    /** Null: no limit, which only the root has. */
+    wallClockMs: number | null;
+    /** How many levels may still open below this node. */
+    depth: number;
+    delegatedTasks: number;
+    tasksPerPlan: number;
+    runners: readonly RunnerId[];
+    /** The models a runner is held to; a runner not named may use any it offers, as the user's allowlist reads. */
+    models: Readonly<Record<RunnerId, readonly string[]>>;
+}
+interface MandateExclusions {
+    protectedPaths: readonly string[];
+}
+interface Mandate {
+    /** What this node may do. */
+    grants: ReadonlySet<Grant>;
+    /** What it may hand a child. */
+    grantable: ReadonlySet<Grant>;
+    /** Read in place of the global level. */
+    autonomy: 'full' | 'guarded';
+    limits: MandateLimits;
+    /** These only accumulate. */
+    exclusions: MandateExclusions;
+    /** One per level, each with its own `!` rules: a command must match at every level (M4). */
+    effectRules: readonly EffectRules[];
+}
+/** What the root's mandate is read from, each where it lives today (M1). */
+interface RootSettings {
+    /** The run's own copy: where a guard or a failure lowers it, and the user's change lands. */
+    level: SupervisorLevel;
+    autorun: boolean;
+    autonomous: boolean;
+    /** The tree's budget; 0 is delegation off (ADR-0055 D21). */
+    delegationTokens: number;
+    /** The effect allowlist, absent where nothing was read. */
+    effects?: EffectRules;
+    runners: readonly RunnerId[];
+    models: Readonly<Record<RunnerId, readonly string[]>>;
+}
+/** What a delegated task asks of the mandate it is given. `grants` names what it asks for past the floor; absent asks for nothing. */
+interface MandateRequest {
+    /** The level of the node narrowing, the root being 0: the one a refusal names. */
+    level: number;
+    grants?: readonly Grant[];
+    autonomy?: Mandate['autonomy'];
+    /** A delegated task must carry one (M5). */
+    tokens?: number;
+    wallClockMs?: number;
+    depth?: number;
+    delegatedTasks?: number;
+    tasksPerPlan?: number;
+    runners?: readonly RunnerId[];
+    models?: Readonly<Record<RunnerId, readonly string[]>>;
+    protectedPaths?: readonly string[];
+    effectRules?: EffectRules;
+}
+interface MandateRefusal {
+    level: number;
+    field: string;
+    asked: string;
+    there: string;
+}
+type Narrowed = {
+    ok: true;
+    mandate: Mandate;
+} | {
+    ok: false;
+    refusal: MandateRefusal;
+};
+declare function mandateRefusalText({ level, field, asked, there }: MandateRefusal): string;
+/**
+ * The root's mandate, as it stands now (M1): built afresh on each read, so an
+ * Act that a guard lowered reads Watch at the next check, and nothing saved
+ * could disagree with the settings.
+ */
+declare function rootMandate(settings: RootSettings): Mandate;
+/**
+ * What holds at a node now (M1): its saved mandate within every ancestor's
+ * `grantable` as it stands, so a change at the root reaches the subtree at the
+ * next check. This reading intersects and refuses nothing: the floor binds
+ * {@link narrow}, which writes a new child, not this.
+ */
+declare function heldMandate(saved: Mandate, ancestors: readonly Mandate[]): Mandate;
+/**
+ * A child's mandate (M4), or the refusal that names the level that refused,
+ * the field, what was asked and what is there. Pure, and written to be proved:
+ * no result is wider than its parent. `parent.limits.tokens` and `wallClockMs`
+ * are what the parent has left, which is the caller's to read.
+ */
+declare function narrow(parent: Mandate, request: MandateRequest): Narrowed;
+/** What a node reads of its own authority, at each check (M1). */
+interface NodeAuthority {
+    /** How far below the root, which is 0 and where a person remains. */
+    readonly depth: number;
+    /** The mandate that holds now. `level` is what the root's is read at; a child's does not depend on it. */
+    mandate(level: SupervisorLevel): Mandate;
+}
+/** The root: its settings read as each check asks, the level included, which each caller names. */
+declare function rootAuthority(settings: () => Omit<RootSettings, 'level'>): NodeAuthority;
 
 /** One call at the command seam, as every route words it (ADR-0029). Task references are resolved here. */
 type ExecutionCommand = {
@@ -3322,6 +4013,18 @@ type ExecutionCommand = {
     confirmed?: boolean;
     seen?: TaskStatus;
 }
+/**
+ * The user takes a task's landed work off the integration branch, before
+ * Merge all, with its landed dependents (ADR-0054). Needs `confirmed`, their
+ * yes to what the preview listed; `seen` is the task ids it listed, and a
+ * set that changed since is refused.
+ */
+ | {
+    command: 'revert_task';
+    task: string;
+    confirmed?: boolean;
+    seen?: string[];
+}
 /** Stop a structured task's running turn, keeping its session: it then waits for the user's message. */
  | {
     command: 'interrupt_task';
@@ -3395,6 +4098,11 @@ type CommandPayload =
  | {
     kind: 'merge';
     result: IsolationMergeResult;
+}
+/** The user's `revert_task`, reverted or stopped: which tasks, or the task and files, or the commands that do it by hand. */
+ | {
+    kind: 'revert';
+    result: IsolationRevertResult;
 };
 /**
  * What a call came to: `message` is written for the caller, a model included,
@@ -3426,19 +4134,6 @@ type Consent = {
  * body is never covered.
  */
 type EffectAllowlist = (body: ScriptBody) => string | null;
-/**
- * What a supervisor at `level` may do. The mandate (#23) replaces this check;
- * nothing above it moves.
- */
-type SupervisorPolicy = (level: SupervisorLevel, command: ExecutionCommandName) => Consent;
-/**
- * The supervisor levels (ADR-0029). Off: it does not act. Watch: it reads and
- * suggests, and every execution command it calls is refused. Act: every
- * command runs without asking — choosing Act is the consent — inside the loop
- * guards; what a command may never do, like allowing an approval, is still
- * refused by the command itself.
- */
-declare const SUPERVISOR_LEVELS: SupervisorPolicy;
 /**
  * A check that stops an actor spinning (ADR-0029's loop guards): the trip —
  * the note naming the guard and what would be accepted, and what the user is
@@ -3467,6 +4162,8 @@ interface ExecutionHost {
     waitsForApproval(taskId: string): boolean;
     /** A start the user consented to approves these tasks, before it acts. */
     approve(taskIds: readonly string[]): void;
+    /** A start under Full with autorun makes the plan approved, as autorun's own start does, so nothing later in the session is refused for it (ADR-0030). */
+    approvePlan(): void;
     /** Full autonomy: starts follow plan approval without a question. */
     autonomous(): boolean;
     /** The user's autorun setting, as it is now (ADR-0030). */
@@ -3477,14 +4174,28 @@ interface ExecutionHost {
     startsHeld(): boolean;
     /** Work is running right now. */
     hasLiveWork(): boolean;
+    /** A usage limit holds the run: what it paused resumes at the reset. */
+    runHeld(): boolean;
+    /** A scheduled run is open, driving the plan or held by a usage limit that gives it back, whether or not anything is live. */
+    scheduledRun(): boolean;
     /** Something will start without being asked again: a start admitted and not yet claimed, or a scheduled resume. */
     startsPending(): boolean;
+    /** A plan the turn in flight submitted, whose start autorun makes as the turn ends (ADR-0030): a start on its way that no run holds yet. */
+    submittedStartWaits(): boolean;
+    /** A loop is carried on, one a body task stopped included; see {@link TaskOrchestrator.loopCarried}. */
+    loopCarried(): boolean;
+    /** A run with nothing starting that something still resumes: a usage limit's reset, or a retry of a failure; see {@link TaskOrchestrator.awaitsResume}. */
+    awaitsResume(): boolean;
+    /** Something will run this loop's check between rounds without being asked; see {@link TaskOrchestrator.loopRunsOn}. */
+    loopRunsOn(taskId: string): boolean;
     /** Something could move a task on without being asked: a start, an attempt in any phase, the scheduler or a usage-limit hold. */
     advancesOnItsOwn(): boolean;
     /** Admit a start that waits before it claims; see {@link StartAdmission}. */
     admitStart(): StartAdmission;
     /** The task's attempt is live: starting, running or landing. */
     running(taskId: string): boolean;
+    /** A conflict repair of the task will start by itself: there is a start to withdraw (ADR-0015). */
+    repairOwed(taskId: string): boolean;
     maxParallel(): number;
     /** The run waits on the user to stash or skip isolation before anything starts. */
     runBlocked(): boolean;
@@ -3504,14 +4215,26 @@ interface ExecutionHost {
      * `left` still wait. Answers the line that says so.
      */
     joinRun(approved: number, left: number): Promise<string>;
+    /** The fresh chance the user's Execute gives what failed, for work it takes in (ADR-0053); none while the scheduler drives the run. */
+    readyFailed(): void;
     startTask(taskId: string, actor: ExecutionActor): Promise<void>;
     /** Force start the task; answers the line saying it waits for its dependencies, when it was queued behind them rather than started. */
     forceStart(taskId: string): Promise<string | undefined>;
     markComplete(taskId: string): Promise<void>;
     markNotDone(taskId: string): Promise<void>;
+    /** What reverting the task would take, as far as the plan can say; see {@link TaskOrchestrator.revertScope}. */
+    revertScope(taskId: string): RevertScope;
+    /** Revert the task's landed work, through the queue it shares with landings. */
+    revertTask(taskId: string): Promise<IsolationRevertResult>;
     interrupt(taskId: string): Promise<void>;
-    stopTask(taskId: string): Promise<void>;
-    stopRun(): void;
+    /** `actor` is who stopped it: the user's stop holds the supervisor back from it (ADR-0029). */
+    stopTask(taskId: string, actor: ExecutionActor): Promise<void>;
+    /** `actor` is who stopped it: the user's Stop stands the supervisor down (ADR-0029). */
+    stopRun(actor: ExecutionActor): void;
+    /** The user's Stop found nothing to stop: what was admitted before it is withdrawn all the same. */
+    stopAsked(): void;
+    /** A start cleared its last check and is about to act; the user's ends their Stop (ADR-0029). */
+    startAsked(actor: ExecutionActor): void;
     retryTask(taskId: string, actor: ExecutionActor): Promise<void>;
     /** End the task as skipped, landing nothing of it; see {@link TaskOrchestrator.skipTask}. */
     skipTask(taskId: string, reason: string | undefined, actor: ExecutionActor): Promise<void>;
@@ -3565,6 +4288,12 @@ interface ExecutionHost {
     awaitEnd(taskId: string, ms: number, signal?: AbortSignal): Promise<void>;
     /** The task's result is owed to the planner, in a turn acting for whoever started it (ADR-0037, R2, R3). */
     owe(taskId: string, to: TaskReportTo): void;
+    /** What waits on a person now, derived afresh (ADR-0053). */
+    escalations(): readonly Escalation[];
+    /** Add the task that merges a conflicted task's branch by hand; false when it has no conflict left. */
+    resolveConflict(taskId: string): Promise<boolean>;
+    /** Replay the run a dirty checkout turned away, stashing first or for this run without isolation. */
+    continueRun(how: 'stash' | 'shared'): Promise<void>;
     /** The end of a task's output, as a planner turn is told it; see {@link taskReport}. */
     reportTail(taskId: string): string | undefined;
 }
@@ -3572,7 +4301,8 @@ interface ExecutionCommandsDeps {
     host: ExecutionHost;
     /** The approval card channel a Guarded start asks through. */
     consent: Pick<IApproval, 'request'>;
-    supervisor?: SupervisorPolicy;
+    /** What this node may do unasked, read at each check (ADR-0056 M1); a root with nothing past what the host says unless set. */
+    authority?: NodeAuthority;
     guards?: readonly LoopGuard[];
     /** What pre-approves a script's effect (ADR-0035); nothing does unless set. */
     effects?: EffectAllowlist;
@@ -3592,7 +4322,7 @@ interface ExecutionCommandsDeps {
 declare class ExecutionCommands {
     private readonly deps;
     private readonly host;
-    private readonly supervisor;
+    private readonly authority;
     private readonly guards;
     private readonly effects;
     private readonly now;
@@ -3616,6 +4346,15 @@ declare class ExecutionCommands {
      * committed, its own edits in the turn included (ADR-0022 P2).
      */
     run(asked: ExecutionCommand, actor: ExecutionActor, signal?: AbortSignal): Promise<CommandOutcome>;
+    /**
+     * The user's answer to an escalation (ADR-0053): the list derived afresh,
+     * and the option chosen dispatched to the existing command for that wait, as
+     * the user, so every check it has still applies and this adds no authority.
+     * It takes no actor because it is the user's alone: no planner tool reaches
+     * it, and the supervisor keeps its own tools. `confirmed` is the user's yes to
+     * an option's `confirm`, which a choice cannot imply.
+     */
+    answerEscalation(id: string, option: string, note?: string, confirmed?: boolean): Promise<CommandOutcome>;
     /** A valid, consented call, from the user's answer where one is needed to the act and its record. */
     private carryOut;
     /**
@@ -3643,23 +4382,26 @@ declare class ExecutionCommands {
      */
     private scriptUnready;
     /**
-     * Who may run a script without the mandate (#23), as ADR-0035's table says.
-     * An effect the user's allowlist covers runs in every row but one, and is
-     * recorded by its rule. In the user's turn: otherwise autorun in Full runs
-     * it (ADR-0030), and failing that they are asked on the card. The
-     * supervisor's level decides for it first: at Watch it is refused, to
-     * suggest it instead, covered or not; at Act it runs, the task it adds
-     * being approved (ADR-0029).
+     * Who may run a script, as ADR-0035's table says. An effect the user's
+     * allowlist covers runs in every row but one, and is recorded by its rule.
+     * In the user's turn: otherwise autorun in Full runs it, on a first plan as
+     * on an approved one (ADR-0030), and failing that they are asked on the
+     * card. The supervisor's level decides for it first: at Watch it is refused,
+     * to suggest it instead, covered or not; at Act it runs, the task it adds
+     * being approved (ADR-0029). A subplanner's is its grants alone (ADR-0056 M6).
      */
     private scriptConsent;
     /**
-     * Of the tasks a planner edit in the user's turn wrote, the ones autorun
-     * approves as the edit commits: all of them, but for a script task, which
-     * runs unasked only where `run_script` would run it unasked (ADR-0035), so
-     * under Guarded it waits for the user unless their effect allowlist covers
-     * it. Its row shows the body verbatim, and starting it is their consent.
+     * Of the tasks a planner edit wrote, the ones autorun approves as the edit
+     * commits. Under Full every one of them, a rewritten script's new body
+     * included, for the user's turn and a supervisor at Act alike. Otherwise only
+     * in the user's turn, and all but a script task, which runs unasked only
+     * where `run_script` would run it unasked (ADR-0035), so under Guarded it
+     * waits for the user unless their effect allowlist covers it. Its row shows
+     * the body verbatim, and starting it is their consent. Below the root this
+     * is the `approve` grant (ADR-0056 M6).
      */
-    autorunApproves(written: readonly Readonly<Task>[]): string[];
+    autorunApproves(actor: ExecutionActor, written: readonly Readonly<Task>[]): string[];
     /**
      * A task `run_script` answered for before it ended has ended: its result
      * joins the timeline beside its start, with who asked and how it was
@@ -3671,16 +4413,22 @@ declare class ExecutionCommands {
      * The tasks a start approves, read from the plan as it stands at the
      * command's last check. Autorun starts a plan as the user's standing
      * instruction, so its start approves what it runs as the user's does; so
-     * does a start under its exception for added tasks. A yes on the card
-     * approves the tasks the card named, and no others.
+     * does a start under Full with autorun. Under Guarded it leaves a script task
+     * the commit left unapproved: that waits for the user (ADR-0035). A yes on
+     * the card approves the tasks the card named, and no others.
      */
     private consented;
     /**
-     * With autorun on and Full, a planner turn may start a task added after the
-     * user approved the plan (ADR-0030). Read at each start, so switching either
-     * off stops it at once; never on a plan the user has not approved.
+     * With autorun on and Full, nobody is asked: a planner turn, or a supervisor
+     * its level lets act, may start anything, on a first plan as on an approved
+     * one (ADR-0030). Read at each start, so switching either off stops it at
+     * once. Below Act the level has refused the call before this is read. A
+     * subplanner has nobody to ask, so `approve` alone says it: its `autonomy`
+     * says what its runners may do, not whether a person is asked (ADR-0056 M7).
      */
-    private addedMayStart;
+    private startsUnattended;
+    /** The mandate that answers for `actor` now: read at each check, so a change reaches the next one (ADR-0056 M1). */
+    private mandateOf;
     /**
      * Guarded means "ask the user first": a planner start in the user's own
      * turn asks, so tasks they have not approved go into the question rather
@@ -3689,12 +4437,23 @@ declare class ExecutionCommands {
      */
     private asksToApprove;
     /**
-     * Who may do what without the mandate (#23): the user's own call needs no
-     * consent, and their own controls are theirs alone; a planner turn may
-     * always end or steer work, and starts it only as the autonomy level says;
-     * the supervisor's level decides for it.
+     * Who may do what, in the one place it is decided (ADR-0056 M6): the user's
+     * own call needs no consent, and their own controls are theirs alone; a turn
+     * the user opened keeps ADR-0029's table, since a person needs no mandate: it
+     * may always end or steer work, and starts it only as the autonomy level says.
+     * The supervisor's level decides for it through its mandate, and a subplanner
+     * has its grants alone, allow or refuse: nobody is there to ask.
      */
-    private consent;
+    consent(actor: ExecutionActor, command: ExecutionCommandName): Consent;
+    private supervisorConsent;
+    private grantConsent;
+    /**
+     * Autorun is the user's standing instruction, so at the root it is not held
+     * to a level: Watch has no `control`, and autorun still starts its plan. Below
+     * the root there is no user behind it, and `approve` and `control` narrow it
+     * (ADR-0056 M6).
+     */
+    private autorunConsent;
     /**
      * A checkpoint asks a person for judgement on the work, so the user answers
      * it from the task's card; the supervisor may only at Act, in a wake-up turn
@@ -3709,8 +4468,16 @@ declare class ExecutionCommands {
      */
     private prepare;
     private prepareRunPlan;
+    /**
+     * What a planner is told of its `run_plan`: it leaves a failure as it is
+     * (ADR-0053), so the line says so, and where nothing was left to start the
+     * run has ended again and the line does not say it runs.
+     */
+    private runningLine;
     /** A start of one task: `run_task`, or a fresh `retry_task`, which also takes a task that failed or waits on the user. */
     private prepareStart;
+    /** Why the work this task builds on keeps a start of it, a fresh one or a continue, from running now; null when it does not. */
+    private heldBehind;
     /**
      * The user's force start goes past what the scheduler waits for, so only
      * what no start could get past is refused here; the start rule decides the
@@ -3742,6 +4509,13 @@ declare class ExecutionCommands {
     private overriddenBy;
     private prepareMarkComplete;
     private prepareMarkNotDone;
+    /**
+     * A revert asks nothing of the run, so unlike an override it waits for no
+     * task that does not depend on the work (ADR-0054). What only git can say —
+     * that it is in the user's branch, that it conflicts — it says as it runs,
+     * in its turn on the queue.
+     */
+    private prepareRevert;
     private prepareInterrupt;
     private prepareCancelResume;
     private prepareCheckpoint;
@@ -3753,6 +4527,8 @@ declare class ExecutionCommands {
      */
     private prepareResume;
     private prepareStop;
+    /** What a refused Stop of a conflicted task can do instead: nothing runs it, so there is something else to press. */
+    private conflictNext;
     private prepareStopRun;
     private prepareMessage;
     /** A message queued behind the running turn, sent now or taken back; one delivered meanwhile is past either. */
@@ -3771,9 +4547,11 @@ declare class ExecutionCommands {
      */
     private skippedRefusal;
     /**
-     * Why a loop's check between rounds is not started from the seam: its loop
-     * runs it again itself, once its body has landed (ADR-0045 L5). Null for
-     * any other task.
+     * Why a loop's check between rounds is not started from the seam: something
+     * will run it, once its body has landed, or nothing will and its body has
+     * yet to land (ADR-0045 L5). Each says only what is true of it. Null for any
+     * other task, and for a check whose fix has landed that nothing else will
+     * run, which a start runs as its next round rather than leave it stranded.
      */
     private betweenRounds;
     /**
@@ -3959,6 +4737,8 @@ interface PlanChangeScope {
     handles?(): ReadonlyMap<string, string>;
     /** A further refusal of what the change leaves: the supervisor's oscillation guard (ADR-0029). */
     guard?(before: readonly Task[], after: readonly Task[]): string | undefined;
+    /** The node, below the root: a child's change is held to its mandate, where a commit would otherwise approve with no command (ADR-0056 M6). Absent, or undefined, at the root. */
+    child?(): NodeAuthority | undefined;
 }
 /** What a whole plan's JSON is held to as it is submitted. */
 interface PlanIntake {
@@ -3992,6 +4772,8 @@ declare class PlanChangeCheck {
     /** A plan's JSON read into tasks as it is submitted; nothing in it reads the plan. */
     private read;
     private rules;
+    /** What a child's mandate leaves out of this change: `replan` for any, and `research` for a research task it brings. */
+    private ungranted;
     private refused;
 }
 
@@ -4129,6 +4911,7 @@ declare class CliAgentAiService implements IAiService {
     nativeSessionId(): string | null;
     /** The compactions the agents reported of their own context, never a subagent's or another thread's: their adapters drop those (ADR-0012 T10). */
     compactions(): number;
+    promptCacheTtlMs(): number | undefined;
     heldSecrets(): readonly string[];
     restart(): void;
     reset(): void;
@@ -4301,6 +5084,8 @@ interface LandedHistory {
  */
 interface PlannerToolsOffer {
     sessionId: string;
+    /** The tools a child's grants leave out of its list, fixed as its session starts (ADR-0056 M6); the root's list is not filtered. */
+    withheld?: readonly string[];
     handler: PlannerToolHandler;
 }
 /**
@@ -4498,6 +5283,8 @@ interface IAiService {
      * T10). Absent where nothing compacts a context in place.
      */
     compactions?(): number;
+    /** How long this planner's prompt cache lasts, as its connector states it; absent when it states none (ADR-0057 R4). */
+    promptCacheTtlMs?(): number | undefined;
     /**
      * Optional: what automatic compaction does for the planner's model now
      * (ADR-0002) — on, off in the settings file, or off for want of a known
@@ -4681,6 +5468,14 @@ declare class PlannerTurn {
 }
 /** What a planner turn may change: the whole plan, or tasks through edits. */
 type PlanChange = 'plan' | 'edit';
+/** A wake-up turn's brief, as `PlannerBriefing` sends it: whole to a context that does not hold it, else a line on a change (ADR-0057 R5). */
+interface WakeBrief {
+    /** Which brief this is: a level's, or a report turn's. */
+    key: string;
+    whole: string;
+    /** All a context holding {@link whole} needs told, and all that may differ between two wake-ups of one brief. */
+    line: string;
+}
 /**
  * A wake-up turn (ADR-0029): a supervisor's turn on wake-up digests alone, no
  * user message in it. What it may do is its level's, decided by the host.
@@ -4695,7 +5490,7 @@ interface WakeUpTurn {
      */
     refused(change: PlanChange): string | undefined;
     /** Told to the model after the digests and never saved, like the plan block: who it is in this turn, and what it may do. */
-    brief?: string;
+    brief?: WakeBrief;
     /**
      * Who the turn acts for at the command seam, read at each call; absent, the
      * supervisor at the run's level. A turn on a report owed to the user's turn
@@ -4918,6 +5713,8 @@ declare class PlannerConversation {
     private readonly blocks;
     private live;
     private openTurn;
+    /** When the live context's newest turn opened; null with no live context. */
+    private requestedAt;
     /**
      * What an API planner's chat condenses its context through during a turn
      * (ADR-0002): the open turn, the history that landed before it, and the
@@ -4926,6 +5723,14 @@ declare class PlannerConversation {
     private readonly compaction;
     constructor(host: PlannerConversationHost);
     get transcript(): readonly ConversationMessage[];
+    /**
+     * When the planner's prefix was last sent, as its provider counts a prompt
+     * cache's life: from the start of a request (ADR-0057 R4). The turn's opening
+     * stands for it: a turn's later calls keep the prefix warm for longer, so
+     * this can only say a wake is due earlier than it had to be. Null with no live
+     * context, whose next turn is a replay.
+     */
+    get lastRequestAt(): number | null;
     /** Whether a planner turn holds the conversation. */
     get isTurnInFlight(): boolean;
     /** Stop the planner turn in flight; it settles as stopped. False when none is. */
@@ -5311,7 +6116,12 @@ declare class PlannerConversation {
      * whole block or what changed (ADR-0012 T10).
      */
     private planView;
-    /** One line per task, subtasks indented under their parent, with stable references — null until the plan has tasks. */
+    /**
+     * One line per task, subtasks indented under their parent, with stable
+     * references — null until the plan has tasks. Past a size only the tasks a
+     * planner acts on get a line (`planWindow`); what a line waits for costs a
+     * start-rule walk, so the rest are not walked.
+     */
     private planRows;
 }
 
@@ -5389,78 +6199,6 @@ interface SessionData {
     plan: LegacyPlanState;
 }
 
-/**
- * The bridge between "core needs an answer" and "a human somewhere is looking
- * at a UI". Core cannot prompt: the human may be at a browser, a TUI, a CLI
- * stream, or a VS Code webview, and on the web server they are on the far end
- * of a socket. So the Session parks a promise here, announces the request
- * through the normal broadcast seam, and every surface answers through the
- * same `resolve(id, granted)` call.
- *
- * Timeouts are load-bearing rather than defensive: a planner turn that blocks
- * forever on an unanswered prompt would hang the whole research loop with no
- * visible cause. On expiry the request resolves to denied and the model gets a
- * normal, actionable tool result. A task runner's request is the exception
- * (ADR-0018, A1): the runner is parked on it rather than a research loop, and
- * it waits for a person — or the supervisor — however long that takes.
- */
-interface PendingApproval {
-    id: string;
-    request: ApprovalRequest;
-    createdAt: string;
-}
-interface PendingApprovalsOptions {
-    /** Denies and resolves after this long with no answer. Default 5 minutes. */
-    timeoutMs?: number;
-    /** Announce a new request to the surfaces. */
-    onRequest?: (pending: PendingApproval) => void;
-    /** Announce that a request is no longer actionable (answered or expired). */
-    onSettled?: (id: string, granted: boolean, settled: {
-        request: ApprovalRequest;
-        decision: ApprovalDecision;
-    }) => void;
-}
-interface AskOptions {
-    /**
-     * An id the caller already announced the request under. One still in use is
-     * refused — denied at once — rather than overwriting the request that has it.
-     */
-    id?: string;
-    /** Wait for an answer however long it takes. */
-    noTimeout?: boolean;
-    /**
-     * Given the answer as the request settles, before anything awaiting the
-     * promise runs: a caller about to tear down what asked (a runner being
-     * stopped) must deliver the answer before it goes.
-     */
-    onDecision?: (decision: ApprovalDecision) => void;
-}
-declare class PendingApprovals {
-    private readonly opts;
-    private readonly entries;
-    private readonly listeners;
-    constructor(opts?: PendingApprovalsOptions);
-    /** Hear each new request once it is announced — the supervisor wakes on a runner's (ADR-0029). */
-    listen(listener: (pending: PendingApproval) => void): () => void;
-    /** Park a request and return the promise the approval policy awaits. */
-    ask(request: ApprovalRequest, options?: AskOptions): Promise<boolean>;
-    /** Park a request whose answer is more than yes or no. */
-    decide(request: ApprovalRequest, options?: AskOptions): Promise<ApprovalDecision>;
-    /**
-     * Answer one request. Returns false when the id is unknown or already
-     * settled. "Allow for this task" on a request that did not offer it is a
-     * plain allow: no grant is made that the requester never proposed.
-     */
-    resolve(id: string, answer: ApprovalAnswer): boolean;
-    /** Everything still awaiting an answer — replayed to a surface that connects late. */
-    outstanding(): PendingApproval[];
-    /**
-     * Deny everything in flight, or only the requests `which` picks. Called on
-     * abort and on session reset.
-     */
-    clear(which?: (request: ApprovalRequest) => boolean, note?: string): void;
-}
-
 /** One repo that kept "Merge all" from touching anything, as part of one line. */
 declare function blockNotice({ repo, reason, files, expected, actual, rebasing }: IsolationMergeBlock): string;
 /** Every repo's reason, in the order "Merge all" named them, so a surface can list them or join them. */
@@ -5719,6 +6457,11 @@ interface GlobalRunSettings {
     supervisorRetryLimit: number;
     /** Reads a wake-up turn may make, in place of a user message's caps. */
     wakeUpReadBudget: number;
+    /**
+     * The token budget of a delegation tree (ADR-0055 D21, ADR-0056 M5); 0 is
+     * delegation off. One value, so delegation is never on with no budget.
+     */
+    delegationTokens: number;
 }
 declare const RUN_SETTINGS_DEFAULTS: Readonly<GlobalRunSettings>;
 declare class RunSettingsError extends Error {
@@ -5744,12 +6487,19 @@ interface UserSettings {
     autorun?: boolean;
     supervisorRetryLimit?: number;
     wakeUpReadBudget?: number;
+    delegationTokens?: number;
     /**
      * Whether an API planner prunes its own context ahead of a call that would
      * pass 90% of its model's window. Absent means on. Set in the file only:
      * no surface offers it.
      */
     plannerAutoCompaction?: boolean;
+    /**
+     * What a task runner loads of the user's own setup: all of it (`user`) or
+     * what a task needs (`minimal`). Absent means `user`. Set in the file only:
+     * no surface offers it.
+     */
+    taskRunnerConfig?: TaskRunnerConfig;
 }
 /**
  * The model allowlist, remembered planner models and enabled runners are shared
@@ -5994,6 +6744,24 @@ interface ExecuteCommandResponse {
     message: string;
     payload?: CommandPayload;
 }
+/**
+ * `GET /api/plans/:id/escalations`: what waits on a person now (ADR-0053). A
+ * client holding a socket has the same list on every status update.
+ */
+interface EscalationsResponse {
+    escalations: Escalation[];
+}
+/**
+ * The body of `POST /api/plans/:id/escalations/answer`, run as the user, and
+ * answered as `execute-command` answers. `confirmed` is the user's yes to the
+ * option's `confirm`.
+ */
+interface AnswerEscalationRequest {
+    id: string;
+    option: string;
+    note?: string;
+    confirmed?: boolean;
+}
 /**
  * A plan as the planner routes return it: the session's plan state, not the
  * `SerializedPlan` a websocket `plan_generated` carries. The two differ —
@@ -6054,6 +6822,8 @@ interface MergeGateEntry {
 interface MergeGateResponse {
     mergeGate: MergeGateEntry[];
 }
+/** A revert that would not go ahead is an answer, not a failure, so it comes back 200 with why (ADR-0054). */
+type TaskRevertPreviewResponse = TaskRevertPreview;
 interface IsolationDiffResponse {
     diff: string;
 }
@@ -6579,6 +7349,8 @@ interface TaskLogView extends BlockList {
     readonly queued: readonly QueuedTaskMessage[];
     /** A turn is running. */
     readonly working: boolean;
+    /** When the open turn began (ISO), for a surface to count from; absent between turns and for a log saved before it was kept (#81). */
+    readonly turnStartedAt?: string;
     /** How the last turn ended; absent before the first one does. */
     readonly lastTurnEnd?: StructuredTurnEnd;
     /** What the runner reported over the attempt, subagents included. */
@@ -6605,6 +7377,70 @@ declare function reduceTaskLog(view: TaskLogView, event: TaskLogEvent): TaskLogV
 /** A whole attempt's events, folded from the start — what a reload shows. */
 declare function replayTaskLog(events: readonly TaskLogEvent[], from?: TaskLogView): TaskLogView;
 
+/** What the label reads: a `TaskLogView`'s blocks, which is all a webview holds of one. */
+type LoggedBlocks = {
+    readonly blocks: readonly DisplayBlock[];
+    readonly turnStartedAt?: string;
+};
+/** What {@link taskActivity} reads of a log: the view's turn flag, and whether the log is an attempt the runner is no longer in. */
+type LoggedTurn = LoggedBlocks & {
+    /** A turn is open in the log, as its `turn_start` said; a log that streams without one has open blocks but this unset. Absent where a surface holds no such flag, which reads as open. */
+    readonly working?: boolean;
+    /** How the last turn ended, as the view says; set means the log has seen a turn end, so what it left open is not a turn. */
+    readonly lastTurnEnd?: StructuredTurnEnd;
+    /** The log is an earlier attempt, browsed: whatever it left open ended with it. */
+    readonly archived?: boolean;
+};
+/**
+ * What a task's runner is busy with, from its log: the latest block still
+ * open decides, since that is what the runner is doing now. Several running
+ * subagents are counted rather than named, as no one of them is the task's
+ * latest work. The label holds runner output — a surface sanitizes it.
+ */
+declare function activityLabel(view: LoggedBlocks): string;
+/** The line above a composer: `busy` animates, and a quiet task's does not. */
+interface TaskActivity {
+    label: string;
+    busy: boolean;
+    /** When the open turn began (ISO): a surface counts from it on its own ticks (#81). Absent for a log saved before turns were dated. */
+    since?: string;
+}
+/**
+ * The activity line of an open task log, or null when it has none to show: a
+ * task not running, and one waiting on a runner request, whose card in the log
+ * already asks the user. A running task whose runner has gone quiet is named
+ * as the plan pane names it and is never `busy`, so a runner that is not
+ * producing anything cannot look as if it were. Nor can a runner between
+ * turns: `busy` needs an open turn, a running subagent that outlived it, or,
+ * in a log that has seen no turn end, a block still open (a stream whose
+ * `turn_start` this view never saw).
+ * A browsed earlier attempt has no line, whatever its log was left open on.
+ * A script task has no exception here, on any surface: it runs no model, but
+ * its log is what it printed, so a step still open is one running.
+ */
+declare function taskActivity(view: LoggedTurn, task: {
+    status: string;
+    idleSince?: string | null;
+    awaitingApproval?: number;
+}): TaskActivity | null;
+
+/**
+ * How long something has run, for an activity line: whole seconds (`42s`),
+ * then minutes and zero-padded seconds (`3m 05s`), then from an hour hours and
+ * zero-padded minutes (`1h 05m`), since seconds mean nothing by then. A
+ * fraction of a unit is dropped, not rounded up, so a time never reads ahead
+ * of the clock. Returns '' for a negative or non-finite input: a start time
+ * ahead of the reader's clock (skew between hosts) is not a duration to show.
+ */
+declare function formatElapsed(ms: number): string;
+/**
+ * The time from `startedAt` (ISO) to `now` (epoch ms), formatted. The clock is
+ * the caller's, so a surface counts on a tick it already draws and a test
+ * fixes it. '' when there is nothing to show: no start (a log saved before
+ * turns were dated) or one that cannot be read.
+ */
+declare function elapsedSince(startedAt: string | undefined, now: number): string;
+
 /**
  * The one-line head of a command row, shared by every surface: the tool's name
  * and the argument that says what the call is about.
@@ -6714,6 +7550,8 @@ declare function aheadOfDraft(text: string, draft: string): string;
 interface TurnGate {
     readonly open: string | null;
     readonly stopped: string | null;
+    /** When the open turn began (ISO), for its elapsed time (#81); absent when none is open or its daemon did not say. */
+    readonly openedAt?: string;
 }
 declare const NO_TURN: TurnGate;
 interface GatedConversation {
@@ -6732,6 +7570,13 @@ declare function followTurn(view: ConversationView, gate: TurnGate, input: Conve
  * turn's late output never lands. Nothing changes when no turn is open.
  */
 declare function stopTurn(view: ConversationView, gate: TurnGate): GatedConversation;
+/**
+ * The turn is over without its `planner_turn_ended` having been heard: its
+ * call failed or returned the plan. The open turn and its start go, so the
+ * next turn does not count from this one's; a stop still standing stays, as
+ * the stopped turn's stragglers have not stopped.
+ */
+declare function closeTurn(gate: TurnGate): TurnGate;
 
 /**
  * Whether the conversation holds anything the collapsed view hides — thinking,
@@ -6856,11 +7701,15 @@ declare function taskStatusKind(task: {
     status: string;
     idleSince?: string | null;
 }): TaskStatusKind;
+/** The word for a running task whose runner has printed nothing for a while (`quiet`). */
+declare const STALLED_LABEL = "Stalled";
 /** What an awaiting_user task waits on (ADR-0018, W1); null when no reason was saved. */
 declare function awaitingLabel(task: {
     status: string;
     awaitingReason?: AwaitingReason;
 }): string | null;
+/** A conflict repair that will start by itself (ADR-0015): progress, in words that ask nothing of the user. */
+declare function repairWaitLabel(wait: RepairWait): string;
 /** "Blocked by #1, #2.1": the failed tasks a blocked task waits on, by reference (ADR-0034). */
 declare function blockedByLabel(refs: readonly string[]): string;
 /** "On hold: could not connect to Ordewell's tools; start it again": why a task is out of the scheduler. */
@@ -6971,6 +7820,8 @@ interface ActionSubject {
     resumeAt?: string | null;
     /** Its last attempt left a runner session to continue (ADR-0018, K1). */
     continuable?: boolean;
+    /** A conflict repair of it will start by itself, which Stop withdraws (ADR-0015). */
+    repairWaits?: unknown;
 }
 /** The actions a task's row offers while a plan runs, in the order they are laid out. */
 declare function taskRowActions(task: ActionSubject, placement?: TaskRowPlacement): TaskRowAction[];
@@ -7099,6 +7950,8 @@ interface TaskRowSubject {
         outcome: string;
         reported?: string;
     } | null;
+    /** Between rounds with nothing to run it: only the run knows that, so it is told (ADR-0045 L5). */
+    loopStranded?: boolean;
     /** The latest attempt's handoff as the plan keeps it (ADR-0047); a row shows it without opening the task. */
     handoff?: HandoffDigest;
 }
@@ -7112,6 +7965,11 @@ interface TaskRowIsolation {
         limit: number;
     };
     repairedFiles?: string[];
+    /** Core's word that its landing can be reverted (ADR-0054); a surface offers the action only then. */
+    revertible?: true;
+    repairWaits?: RepairWait;
+    /** The task added to resolve its conflict, by id. */
+    resolver?: string;
 }
 /**
  * The plan a row labels its references against: the tree, so a subtask's
@@ -7234,10 +8092,16 @@ interface TaskRowView {
     autonomous: boolean;
     /** The repos its isolated work changed, by path; empty for a group of one. */
     repos: string[];
-    /** Integration stopped on a conflict: the one isolation state that needs the user. */
+    /** Integration stopped on a conflict: the one isolation state that needs the user. `resolver` is the task, by reference, that has it; then a second is not offered. */
     conflict: {
         repo: string | null;
         files: string | null;
+        resolver: string | null;
+    } | null;
+    /** A conflict repair that starts by itself once what it waits for clears (ADR-0015): `label` says what, in sentence case. Progress, so `conflict` is null. */
+    repairWaiting: {
+        label: string;
+        files: string | null;
     } | null;
     /** A conflict repair in flight (ADR-0015) — progress, not a blocker. */
     repairing: {
@@ -7270,6 +8134,8 @@ interface TaskRowView {
     dependencies: string[];
     /** What the row offers while a plan runs. */
     actions: TaskRowAction[];
+    /** Its landed work can be reverted before Merge all (ADR-0054): a surface offers Revert only then, and core's preview says the rest. */
+    revertible: boolean;
     /** The one mark its toggle sets. */
     mark: 'complete' | 'uncomplete';
     opsEditable: boolean;
@@ -7313,6 +8179,8 @@ interface TaskLogHeaderTask {
     idleSince?: string | null;
     /** Its last attempt left a runner session the task's composer can continue (ADR-0018, K1). */
     continuable?: boolean;
+    /** A conflict repair of it starts by itself once this clears (ADR-0015). */
+    repairWaits?: RepairWait;
     attemptUsage?: readonly AttemptUsage[];
 }
 /**
@@ -7401,6 +8269,21 @@ type OverrideDirection = 'complete' | 'uncomplete';
  * completion, never the work or what already ran on it.
  */
 declare function manualOverrideConfirmation(direction: OverrideDirection, label: string): string;
+/** What a revert does (ADR-0054), told with the list of tasks it takes: the same words on every surface. */
+declare const revertEffect = "Its landed work comes off the integration branch, newest first, and each task listed is held as not started until you retry it. Nothing in your own branch changes.";
+/** How a revert's confirmation calls a task: a subtask's order alone would name a top-level task. */
+declare function revertTaskRef(task: {
+    order: number;
+    ref?: string;
+}): string;
+/** One task of a revert's confirmation: `dependent` is one that goes with the task the user chose. */
+declare function revertListLine(task: {
+    order: number;
+    ref?: string;
+    title: string;
+    repos: readonly string[];
+    dependent: boolean;
+}): string;
 /** Why a manual override waits for the run to stop (ADR-0029); `label` names the task. */
 declare function manualOverrideStopFirst(direction: OverrideDirection, label: string): string;
 interface NewTaskFields {
@@ -7430,11 +8313,24 @@ declare const automergeSummary: (run: GlobalRunSettings) => string;
 declare const PLANNED_WITH_LABEL = "Planned-with line in commits Ordewell writes";
 declare const trailerSummary: (run: GlobalRunSettings) => string;
 declare const autorunSummary: (run: GlobalRunSettings) => string;
+declare const delegationSummary: (run: GlobalRunSettings) => string;
+/**
+ * Whether any surface offers the delegation setting. Off until a delegated task
+ * exists (ADR-0055 D21): until then a control for it promises something that
+ * does nothing and warns about tokens that cannot be spent. The setting, its
+ * validation and its stored value stay in core and stay inert; the delegated-task
+ * slice turns this on, and only here.
+ */
+declare const DELEGATION_OFFERED = false;
 declare const ACT_RISK = "Tasks it adds run too, ops tasks included, which can act on real systems unattended.";
-declare const AUTORUN_RISK = "Plans start without review, ops tasks included, which can act on real systems unattended. In Full, the planner may also start tasks it adds later.";
+declare const AUTORUN_RISK = "Plans start without review, ops tasks included, which can act on real systems unattended. In Full nobody is asked at all: the planner may start anything, script tasks included, from a plan no person read.";
+/** What turning delegation on accepts below the root, as Act and autorun accept it at the root (ADR-0056 M9). */
+declare const DELEGATION_RISK = "A subplanner approves and runs its own plan, and no person reads it. Its change tasks keep the network they have in a flat run, so an instruction injected into something a subplanner read can become a plan nobody read, and run with that network.";
 /** `on`/`off` as a switch's value; null for anything else. */
 declare function parseSwitch(arg: string): boolean | null;
+/** A delegation setting as typed: `off`, which is 0, or the tree's budget in tokens; null for anything else. */
+declare function parseDelegation(arg: string): number | null;
 /** A whole number at least `min`, as typed; null for anything else. */
 declare function parseCount(arg: string | undefined, min: number): number | null;
 
-export { type DiffRowKind as $, ACT_RISK as A, type BlockingSubject as B, CHAT_COMMANDS as C, type CommandBlock as D, type CommandDescriptor as E, type CommandOutcome as F, type CommandPayload as G, type CommandStatus as H, type CommandsResponse as I, type CompactionBlock as J, type CompactionStatus as K, type Consent as L, type ContextCondenseRequest as M, ConversationBusyError as N, type ConversationCompactResponse as O, type ConversationCompaction as P, ConversationEditError as Q, type ConversationForkResponse as R, type ConversationInput as S, type ConversationRequest as T, type ConversationRewindResponse as U, type ConversationTurn as V, type ConversationView as W, DEFAULT_WEB_READ_BUDGET as X, type DaemonErrorCode as Y, type DecideOptions as Z, type DiffRow as _, AUTORUN_RISK as a, type PendingApproval as a$, type DiffStat as a0, type DisplayBlock as a1, EMPTY_CONVERSATION as a2, EMPTY_HOLD as a3, EMPTY_RUN as a4, EMPTY_TASK_LOG as a5, EMPTY_TASK_LOG_FOLLOW as a6, type ErrorBody as a7, type ExecuteCommandResponse as a8, type ExecuteResponse as a9, type LiveTail as aA, type LiveTailOptions as aB, type LocalEntry as aC, type LoopCheckFacts as aD, type LoopCheckState as aE, type LoopGuard as aF, type MappedTool as aG, type MarkdownToken as aH, type MergeGateEntry as aI, type MergeGateResponse as aJ, type MergeWordingHandoff as aK, type MessageBlock as aL, type MessageRole as aM, type ModelsResponse as aN, NOT_STARTED as aO, NO_TURN as aP, type NewTaskFields as aQ, type NotificationAction as aR, OUTPUT_LINES_DEFAULT as aS, OUTPUT_LINES_MAX as aT, type OkResponse as aU, type OpRef as aV, type OpRefusal as aW, type OrchestratorObserver as aX, type OutputPreview as aY, type OverrideDirection as aZ, PLANNED_WITH_LABEL as a_, type ExecutionCommand as aa, ExecutionCommands as ab, type ExecutionHost as ac, type ExecutionSummary as ad, type GatedConversation as ae, type GeneratePlanResponse as af, type GlobalRunSettings as ag, HEADLESS_CLI_COMMANDS as ah, type HandoffBlock as ai, type HandoffForkRepo as aj, type HandoffPeekSubject as ak, type IAiService as al, IDLE_ACTIVITY as am, type INotification as an, type IWebFetcher as ao, type IsolationDiffResponse as ap, type IsolationMergeResponse as aq, type IsolationPreviewNotice as ar, type IsolationPreviewResponse as as, IsolationRunController as at, LEASE_HEARTBEAT_MS as au, LEASE_STALE_MS as av, LeaseHost as aw, type LeaseHostKind as ax, type LeaseHostOptions as ay, type LiveOutputLookup as az, type AccountLimitBucket as b, type SessionData as b$, PendingApprovals as b0, type PendingApprovalsOptions as b1, type PlanBlock as b2, type PlanBlocks as b3, type PlanIntake as b4, type PlanMarkerStatus as b5, type PlanResponse as b6, type PlanSnapshot as b7, PlanStore as b8, type PlannerCommandSyntax as b9, type RewindTarget as bA, type RewindTargetsResponse as bB, type RunActivity as bC, type RunInput as bD, type RunMergeView as bE, RunSettingsError as bF, type RunSnapshotFrame as bG, type RunTask as bH, type RunTaskStatus as bI, type RunView as bJ, type RunnerAuth as bK, type RunnerAuthExec as bL, type RunnerAuthExecOptions as bM, type RunnerAuthExecResult as bN, type RunnerCatalog as bO, type RunnerLoadedBlock as bP, type RunnersResponse as bQ, STOPPED_BEFORE_START as bR, SUPERVISOR_LEVELS as bS, SUPERVISOR_LEVEL_LABEL as bT, type SerializedConversationMessage as bU, type SerializedPendingTurn as bV, type SerializedPlan as bW, type SerializedTask as bX, type SerializedTaskStatus as bY, type ServerInfoResponse as bZ, type SessionBroadcaster as b_, type PlannerContextDeps as ba, type PlannerContextStatus as bb, PlannerConversation as bc, type PlannerConversationHost as bd, type PlannerModelCandidate as be, type PlannerModelChoice as bf, PlannerModelMemory as bg, type PlannerModelRecall as bh, type PlannerModelStore as bi, type PlannerModes as bj, type PlannerNotReady as bk, PlannerNotReadyError as bl, type PlannerReadinessConfig as bm, type PlannerSubmission as bn, PlannerTurnDiscardedError as bo, PlannerTurnStoppedError as bp, PlannerUsageLimitError as bq, type PrdResponse as br, type PromptHold as bs, REPORT_PREVIEW_LINES as bt, RUN_SETTINGS_DEFAULTS as bu, type ReadRunnerAuthOptions as bv, type RefTask as bw, ResearchTasks as bx, type ResolveAll as by, type ResolveConflictResponse as bz, type AccountLimitSnapshot as c, type TaskRowPlacement as c$, type SessionFrame as c0, type SessionHeld as c1, SessionHeldError as c2, type SessionLease as c3, type SessionLeaseRecord as c4, type SessionListResponse as c5, type SessionMessage as c6, type SessionMeta as c7, type SessionNotice as c8, type SessionResponse as c9, type TaskLogBatch as cA, type TaskLogEvent as cB, type TaskLogFollow as cC, type TaskLogFollowInput as cD, type TaskLogHeaderKind as cE, type TaskLogHeaderTask as cF, type TaskLogHeaderUsage as cG, type TaskLogHeaderView as cH, type TaskLogResponse as cI, type TaskLogView as cJ, type TaskMessageResponse as cK, type TaskOp as cL, TaskOrchestrator as cM, type TaskOrchestratorDeps as cN, type TaskOrchestratorOptions as cO, type TaskOutputSource as cP, type TaskPlacement as cQ, type TaskQuery as cR, type TaskQueryCatalog as cS, type TaskQueryField as cT, type TaskRef as cU, type TaskRowAction as cV, type TaskRowContext as cW, type TaskRowHandoff as cX, type TaskRowIsolation as cY, type TaskRowKind as cZ, type TaskRowLoop as c_, type SettingsResponse as ca, SettingsService as cb, type SettingsUpdateResponse as cc, type SkillInvocation as cd, type SkillLoadBlock as ce, type SkillToken as cf, type StartAdmission as cg, type StopResponse as ch, type StreamStamp as ci, type SubagentBlock as cj, type SubagentChild as ck, type SubagentStatus as cl, type SupervisorPolicy as cm, type SurfacePlan as cn, type SurfacePlanState as co, type SurfaceTask as cp, TASK_QUERY_ANSWER_MAX_CHARS as cq, TASK_QUERY_ANSWER_OR_OPS as cr, TASK_QUERY_FIELDS as cs, TASK_QUERY_PROTOCOL as ct, TASK_QUERY_REMINDER as cu, TERMINAL_UI_COMMANDS as cv, type TakenPrompt as cw, type TaskAction as cx, type TaskAttemptSnapshot as cy, type TaskLogAttemptsResponse as cz, type AccountLimitStatus as d, describeMergeResult as d$, type TaskRowSubject as d0, type TaskRowUsage as d1, type TaskRowView as d2, type TaskRunFacts as d3, type TaskStatusKind as d4, type ThinkingDisplayBlock as d5, type ToolBlock as d6, type ToolHeadline as d7, type ToolStatus as d8, type TreeTask as d9, assignmentIssueText as dA, attachingLabel as dB, automergeSummary as dC, autorunSummary as dD, awaitingLabel as dE, blockNotice as dF, blockNotices as dG, blockedByLabel as dH, blockingFailures as dI, canMergeTasks as dJ, canSetDependencies as dK, canSplitTask as dL, capConflictFiles as dM, cardEditNeedsUnstarted as dN, cardEditable as dO, checkoutRule as dP, classifyOutcome as dQ, coalesceTaskLog as dR, compactionText as dS, confirmedOverride as dT, createAiService as dU, dependencyCandidates as dV, dependentsNotice as dW, dependentsOf as dX, describeHeld as dY, describeHolder as dZ, describeIsolationPreview as d_, TurnBudgets as da, type TurnGate as db, type UsageBlock as dc, type UserSettings as dd, WAITS_FOR_APPROVAL_LABEL as de, type WakeUpItem as df, type WebRead as dg, type WebReadDecision as dh, type WebReadOptions as di, WebReadPolicy as dj, type Worded as dk, type WorkspacesResponse as dl, abbreviateHome as dm, accountLimitPercentText as dn, accountLimitWindowLabel as dp, accountLimitsOf as dq, accountLimitsText as dr, accountLimitsTitle as ds, aheadOfDraft as dt, applyTaskOps as du, approvalKindText as dv, approvalLabel as dw, approvalStatusText as dx, assignedRunnerOf as dy, assignmentIssue as dz, type AccountLimitWindow as e, ranSealed as e$, describePlannerNotReady as e0, diffRows as e1, diffStat as e2, diffSummary as e3, digestTaskLog as e4, drainNext as e5, editableWhileRunning as e6, executionSummary as e7, followTaskLog as e8, followTurn as e9, mapAgentTool as eA, markAction as eB, markdownHtml as eC, markdownTokens as eD, mergeOutcome as eE, mergeTarget as eF, namedRepos as eG, newTaskFields as eH, noExecutorRefusal as eI, normalizeAgentArgs as eJ, opRefusalText as eK, opsEditable as eL, outputLines as eM, outputPreview as eN, overrideNeedsConfirmation as eO, parseCount as eP, parseSwitch as eQ, parseTaskOpsJson as eR, parseTaskQueryJson as eS, pastGateConfirmation as eT, planBlocks as eU, planMarkerParts as eV, plannerMessage as eW, plannerNotReady as eX, plannerNotReadyFor as eY, plannerTranscript as eZ, processLeaseHost as e_, fromTranscript as ea, getSettingsPath as eb, handoffBaseLine as ec, handoffBranchName as ed, handoffFindingsText as ee, handoffPeekParts as ef, hasAccountLimits as eg, hasHiddenDetail as eh, hasLongReport as ei, holdLabel as ej, holdPrompt as ek, isFileEditTool as el, isRepoGroup as em, isTaskRunning as en, lastServedModel as eo, loadedSkillTokens as ep, logContinues as eq, logResumes as er, loopBodyLabel as es, loopBodyRound as et, loopCheckLabel as eu, loopCheckState as ev, loopLeaveNotice as ew, loopRowParts as ex, manualOverrideConfirmation as ey, manualOverrideStopFirst as ez, type AccountLimitsFrame as f, truncateCheckpointSummary as f$, readRunnerAuth as f0, receiptLabel as f1, reconcileApprovals as f2, recordRunnerAuth as f3, recordedRunnerAuth as f4, reduceConversation as f5, reduceRun as f6, reduceTaskLog as f7, renderTaskQueryAnswer as f8, repairedLanded as f9, supervisorSummary as fA, surfacePlan as fB, surfacePlanState as fC, takeAt as fD, taskActionCommand as fE, taskChatAvailable as fF, taskLogCommands as fG, taskLogForSurface as fH, taskLogHeaderView as fI, taskOrderLabel as fJ, taskPlacement as fK, taskQuerySignature as fL, taskRef as fM, taskRefOf as fN, taskRowActions as fO, taskRowView as fP, taskStartedNotice as fQ, taskStatusKind as fR, textHasTaskOps as fS, textHasTaskQuery as fT, titledRefs as fU, titledTaskRef as fV, titledTaskRefOf as fW, toTaskLogEvent as fX, toolHeadline as fY, trailerSummary as fZ, trimToolOutput as f_, repairedNotice as fa, repeatingChecks as fb, replayTaskLog as fc, repoBaseLine as fd, repoResultLines as fe, reposWithWork as ff, resetRunnerAuth as fg, resolveSkillInvocation as fh, resolveTaskRef as fi, resolveUserTaskRef as fj, resumeLabel as fk, resumeTime as fl, runHoldsEditors as fm, runSettingsOf as fn, runnerToolSubject as fo, scriptExitText as fp, scriptRunText as fq, secondsText as fr, serializePlan as fs, serializeTask as ft, serializeTaskStatus as fu, skillTokens as fv, skippedLabel as fw, stopTurn as fx, subtreeIds as fy, summarizeToolCall as fz, type AccountLimitsMessage as g, unsendAll as g0, unsendLatest as g1, wakeUpItems as g2, walkPlan as g3, withoutSealedMark as g4, workspaceEnvOf as g5, type AdoptSessionResponse as h, type ApplyTaskOpsResult as i, type ApprovalAnswerResponse as j, type ApprovalBlock as k, type ApprovalRequestMessage as l, type ApprovalStatus as m, type ApprovalsResponse as n, type ApproveReviewResponse as o, type AskOptions as p, type AssignmentCatalog as q, type AssignmentIssue as r, type AssignmentScope as s, type AssignmentWriter as t, type AutoMergeTrigger as u, CHECKPOINT_TRUNCATE_LENGTH as v, type CancelPlanningResponse as w, type CancelResumeResponse as x, CliAgentAiService as y, type CliAgentAiServiceDeps as z };
+export { type DaemonErrorCode as $, ACT_RISK as A, type BlockingSubject as B, CHAT_COMMANDS as C, type CliAgentAiServiceDeps as D, type CommandBlock as E, type CommandDescriptor as F, type CommandOutcome as G, type CommandPayload as H, type CommandStatus as I, type CommandsResponse as J, type CompactionBlock as K, type CompactionStatus as L, type Consent as M, type ContextCondenseRequest as N, ConversationBusyError as O, type ConversationCompactResponse as P, type ConversationCompaction as Q, ConversationEditError as R, type ConversationForkResponse as S, type ConversationInput as T, type ConversationRequest as U, type ConversationRewindResponse as V, type ConversationTurn as W, type ConversationView as X, DEFAULT_WEB_READ_BUDGET as Y, DELEGATION_OFFERED as Z, DELEGATION_RISK as _, AUTORUN_RISK as a, type MergeGateEntry as a$, type DecideOptions as a0, type DiffRow as a1, type DiffRowKind as a2, type DiffStat as a3, type DisplayBlock as a4, EMPTY_CONVERSATION as a5, EMPTY_HOLD as a6, EMPTY_RUN as a7, EMPTY_TASK_LOG as a8, EMPTY_TASK_LOG_FOLLOW as a9, IDLE_ACTIVITY as aA, type INotification as aB, type IWebFetcher as aC, type IsolationDiffResponse as aD, type IsolationMergeResponse as aE, type IsolationPreviewNotice as aF, type IsolationPreviewResponse as aG, IsolationRunController as aH, LEASE_HEARTBEAT_MS as aI, LEASE_STALE_MS as aJ, LeaseHost as aK, type LeaseHostKind as aL, type LeaseHostOptions as aM, type LiveOutputLookup as aN, type LiveTail as aO, type LiveTailOptions as aP, type LocalEntry as aQ, type LoopCheckFacts as aR, type LoopCheckState as aS, type LoopGuard as aT, type Mandate as aU, type MandateExclusions as aV, type MandateLimits as aW, type MandateRefusal as aX, type MandateRequest as aY, type MappedTool as aZ, type MarkdownToken as a_, type EffectRules as aa, type ErrorBody as ab, type Escalation as ac, type EscalationInput as ad, type EscalationKind as ae, type EscalationOption as af, type EscalationOptionId as ag, type EscalationRun as ah, type EscalationsResponse as ai, type ExecuteCommandResponse as aj, type ExecuteResponse as ak, type ExecutionCommand as al, ExecutionCommands as am, type ExecutionHost as an, type ExecutionSummary as ao, FLOOR_GRANTS as ap, GRANTS as aq, type GatedConversation as ar, type GeneratePlanResponse as as, type GlobalRunSettings as at, type Grant as au, HEADLESS_CLI_COMMANDS as av, type HandoffBlock as aw, type HandoffForkRepo as ax, type HandoffPeekSubject as ay, type IAiService as az, type AccountLimitBucket as b, type RootSettings as b$, type MergeGateResponse as b0, type MergeWordingHandoff as b1, type MessageBlock as b2, type MessageRole as b3, type ModelsResponse as b4, NOT_STARTED as b5, NO_TURN as b6, type Narrowed as b7, type NewTaskFields as b8, type NodeAuthority as b9, type PlannerModelChoice as bA, PlannerModelMemory as bB, type PlannerModelRecall as bC, type PlannerModelStore as bD, type PlannerModes as bE, type PlannerNotReady as bF, PlannerNotReadyError as bG, type PlannerReadinessConfig as bH, type PlannerSubmission as bI, PlannerTurnDiscardedError as bJ, PlannerTurnStoppedError as bK, PlannerUsageLimitError as bL, type PrdResponse as bM, type PromptHold as bN, REPORT_PREVIEW_LINES as bO, RUN_SETTINGS_DEFAULTS as bP, type ReadRunnerAuthOptions as bQ, type RefTask as bR, ResearchTasks as bS, type ResolveAll as bT, type ResolveConflictResponse as bU, type RevertPreviewTask as bV, type RevertRefusal as bW, type RevertRefusalReason as bX, type RevertScope as bY, type RewindTarget as bZ, type RewindTargetsResponse as b_, type NotificationAction as ba, OUTPUT_LINES_DEFAULT as bb, OUTPUT_LINES_MAX as bc, type OkResponse as bd, type OpRef as be, type OpRefusal as bf, type OrchestratorObserver as bg, type OutputPreview as bh, type OverrideDirection as bi, PLANNED_WITH_LABEL as bj, type PendingApproval as bk, PendingApprovals as bl, type PendingApprovalsOptions as bm, type PlanBlock as bn, type PlanBlocks as bo, type PlanIntake as bp, type PlanMarkerStatus as bq, type PlanResponse as br, type PlanSnapshot as bs, PlanStore as bt, type PlannerCommandSyntax as bu, type PlannerContextDeps as bv, type PlannerContextStatus as bw, PlannerConversation as bx, type PlannerConversationHost as by, type PlannerModelCandidate as bz, type AccountLimitSnapshot as c, type TaskLogBatch as c$, type RunActivity as c0, type RunInput as c1, type RunMergeView as c2, RunSettingsError as c3, type RunSnapshotFrame as c4, type RunTask as c5, type RunTaskStatus as c6, type RunView as c7, type RunnerAuth as c8, type RunnerAuthExec as c9, type SessionResponse as cA, type SettingsResponse as cB, SettingsService as cC, type SettingsUpdateResponse as cD, type SkillInvocation as cE, type SkillLoadBlock as cF, type SkillToken as cG, type StartAdmission as cH, type StopResponse as cI, type StreamStamp as cJ, type SubagentBlock as cK, type SubagentChild as cL, type SubagentStatus as cM, type SurfacePlan as cN, type SurfacePlanState as cO, type SurfaceTask as cP, TASK_QUERY_ANSWER_MAX_CHARS as cQ, TASK_QUERY_ANSWER_OR_OPS as cR, TASK_QUERY_FIELDS as cS, TASK_QUERY_PROTOCOL as cT, TASK_QUERY_REMINDER as cU, TERMINAL_UI_COMMANDS as cV, type TakenPrompt as cW, type TaskAction as cX, type TaskActivity as cY, type TaskAttemptSnapshot as cZ, type TaskLogAttemptsResponse as c_, type RunnerAuthExecOptions as ca, type RunnerAuthExecResult as cb, type RunnerCatalog as cc, type RunnerLoadedBlock as cd, type RunnersResponse as ce, SHAPE_LIMITS as cf, STALLED_LABEL as cg, STOPPED_BEFORE_START as ch, SUPERVISOR_LEVEL_LABEL as ci, type SerializedConversationMessage as cj, type SerializedPendingTurn as ck, type SerializedPlan as cl, type SerializedTask as cm, type SerializedTaskStatus as cn, type ServerInfoResponse as co, type SessionBroadcaster as cp, type SessionData as cq, type SessionFrame as cr, type SessionHeld as cs, SessionHeldError as ct, type SessionLease as cu, type SessionLeaseRecord as cv, type SessionListResponse as cw, type SessionMessage as cx, type SessionMeta as cy, type SessionNotice as cz, type AccountLimitStatus as d, approvalStatusText as d$, type TaskLogEvent as d0, type TaskLogFollow as d1, type TaskLogFollowInput as d2, type TaskLogHeaderKind as d3, type TaskLogHeaderTask as d4, type TaskLogHeaderUsage as d5, type TaskLogHeaderView as d6, type TaskLogResponse as d7, type TaskLogView as d8, type TaskMessageResponse as d9, type ToolBlock as dA, type ToolHeadline as dB, type ToolStatus as dC, type TreeTask as dD, TurnBudgets as dE, type TurnGate as dF, type UsageBlock as dG, type UserSettings as dH, WAITS_FOR_APPROVAL_LABEL as dI, type WakeUpItem as dJ, type WebRead as dK, type WebReadDecision as dL, type WebReadOptions as dM, WebReadPolicy as dN, type Worded as dO, type WorkspacesResponse as dP, abbreviateHome as dQ, accountLimitPercentText as dR, accountLimitWindowLabel as dS, accountLimitsOf as dT, accountLimitsText as dU, accountLimitsTitle as dV, activityLabel as dW, aheadOfDraft as dX, applyTaskOps as dY, approvalKindText as dZ, approvalLabel as d_, type TaskOp as da, TaskOrchestrator as db, type TaskOrchestratorDeps as dc, type TaskOrchestratorOptions as dd, type TaskOutputSource as de, type TaskPlacement as df, type TaskQuery as dg, type TaskQueryCatalog as dh, type TaskQueryField as di, type TaskRef as dj, type TaskRevertPreview as dk, type TaskRevertPreviewResponse as dl, type TaskRowAction as dm, type TaskRowContext as dn, type TaskRowHandoff as dp, type TaskRowIsolation as dq, type TaskRowKind as dr, type TaskRowLoop as ds, type TaskRowPlacement as dt, type TaskRowSubject as du, type TaskRowUsage as dv, type TaskRowView as dw, type TaskRunFacts as dx, type TaskStatusKind as dy, type ThinkingDisplayBlock as dz, type AccountLimitWindow as e, logContinues as e$, assignedRunnerOf as e0, assignmentIssue as e1, assignmentIssueText as e2, attachingLabel as e3, automergeSummary as e4, autorunSummary as e5, awaitingLabel as e6, blockNotice as e7, blockNotices as e8, blockedByLabel as e9, digestTaskLog as eA, drainNext as eB, editableWhileRunning as eC, effectRuleFor as eD, elapsedSince as eE, escalations as eF, executionSummary as eG, followTaskLog as eH, followTurn as eI, formatElapsed as eJ, fromTranscript as eK, getSettingsPath as eL, handoffBaseLine as eM, handoffBranchName as eN, handoffFindingsText as eO, handoffPeekParts as eP, hasAccountLimits as eQ, hasHiddenDetail as eR, hasLongReport as eS, heldMandate as eT, holdLabel as eU, holdPrompt as eV, isFileEditTool as eW, isRepoGroup as eX, isTaskRunning as eY, lastServedModel as eZ, loadedSkillTokens as e_, blockingFailures as ea, canMergeTasks as eb, canSetDependencies as ec, canSplitTask as ed, capConflictFiles as ee, cardEditNeedsUnstarted as ef, cardEditable as eg, checkoutRule as eh, classifyOutcome as ei, closeTurn as ej, coalesceTaskLog as ek, compactionText as el, confirmedOverride as em, createAiService as en, delegationSummary as eo, dependencyCandidates as ep, dependentsNotice as eq, dependentsOf as er, describeHeld as es, describeHolder as et, describeIsolationPreview as eu, describeMergeResult as ev, describePlannerNotReady as ew, diffRows as ex, diffStat as ey, diffSummary as ez, type AccountLimitsFrame as f, resumeTime as f$, logResumes as f0, loopBodyLabel as f1, loopBodyRound as f2, loopCheckLabel as f3, loopCheckState as f4, loopLeaveNotice as f5, loopRowParts as f6, mandateRefusalText as f7, manualOverrideConfirmation as f8, manualOverrideStopFirst as f9, plannerNotReady as fA, plannerNotReadyFor as fB, plannerTranscript as fC, processLeaseHost as fD, ranSealed as fE, readRunnerAuth as fF, receiptLabel as fG, reconcileApprovals as fH, recordRunnerAuth as fI, recordedRunnerAuth as fJ, reduceConversation as fK, reduceRun as fL, reduceTaskLog as fM, renderTaskQueryAnswer as fN, repairWaitLabel as fO, repairedLanded as fP, repairedNotice as fQ, repeatingChecks as fR, replayTaskLog as fS, repoBaseLine as fT, repoResultLines as fU, reposWithWork as fV, resetRunnerAuth as fW, resolveSkillInvocation as fX, resolveTaskRef as fY, resolveUserTaskRef as fZ, resumeLabel as f_, mapAgentTool as fa, markAction as fb, markdownHtml as fc, markdownTokens as fd, mergeOutcome as fe, mergeTarget as ff, namedRepos as fg, narrow as fh, newTaskFields as fi, noExecutorRefusal as fj, normalizeAgentArgs as fk, opRefusalText as fl, opsEditable as fm, outputLines as fn, outputPreview as fo, overrideNeedsConfirmation as fp, parseCount as fq, parseDelegation as fr, parseEffectAllowlist as fs, parseSwitch as ft, parseTaskOpsJson as fu, parseTaskQueryJson as fv, pastGateConfirmation as fw, planBlocks as fx, planMarkerParts as fy, plannerMessage as fz, type AccountLimitsMessage as g, revertEffect as g0, revertListLine as g1, revertTaskRef as g2, rootAuthority as g3, rootMandate as g4, runHoldsEditors as g5, runSettingsOf as g6, runnerToolSubject as g7, scriptExitText as g8, scriptRunText as g9, taskStartedNotice as gA, taskStatusKind as gB, textHasTaskOps as gC, textHasTaskQuery as gD, titledRefs as gE, titledTaskRef as gF, titledTaskRefOf as gG, toTaskLogEvent as gH, toolHeadline as gI, trailerSummary as gJ, trimToolOutput as gK, truncateCheckpointSummary as gL, unsendAll as gM, unsendLatest as gN, wakeUpItems as gO, walkPlan as gP, withoutSealedMark as gQ, workspaceEnvOf as gR, secondsText as ga, serializePlan as gb, serializeTask as gc, serializeTaskStatus as gd, skillTokens as ge, skippedLabel as gf, stopTurn as gg, subtreeIds as gh, summarizeToolCall as gi, supervisorSummary as gj, surfacePlan as gk, surfacePlanState as gl, takeAt as gm, taskActionCommand as gn, taskActivity as go, taskChatAvailable as gp, taskLogCommands as gq, taskLogForSurface as gr, taskLogHeaderView as gs, taskOrderLabel as gt, taskPlacement as gu, taskQuerySignature as gv, taskRef as gw, taskRefOf as gx, taskRowActions as gy, taskRowView as gz, type AdoptSessionResponse as h, type AnswerEscalationRequest as i, type ApplyTaskOpsResult as j, type ApprovalAnswerResponse as k, type ApprovalBlock as l, type ApprovalRequestMessage as m, type ApprovalStatus as n, type ApprovalsResponse as o, type ApproveReviewResponse as p, type AskOptions as q, type AssignmentCatalog as r, type AssignmentIssue as s, type AssignmentScope as t, type AssignmentWriter as u, type AutoMergeTrigger as v, CHECKPOINT_TRUNCATE_LENGTH as w, type CancelPlanningResponse as x, type CancelResumeResponse as y, CliAgentAiService as z };