@wjarka/cezarion 0.15.1 → 0.16.0

package/dist/workflows/run.d.ts

@@ -1,13 +1,15 @@
-import { type CiWait, type CiWaitRequest } from '../contract/index.js';
+import { type PreviewStopRequest, type PreviewStopResult, type CiWait, type CiWaitRequest, type PreviewServeRequest, type PreviewServeResult } from '../contract/index.js';
+import { type PreviewHostLike } from '../preview/registration.ts';
 import { type WorkerAccountBinding } from '../delegation/execution-identity.ts';
 import type { DelegationProvisioner } from '../delegation/provision.ts';
+import { type CwdSource } from '../delegation/process-liveness.ts';
 import type { RunnerId } from '../core/agent-runner.ts';
 import { type AgentInput, type WorkerStopResult, type WorkerWait, type WorkerWaitRequest, type RequestWaitRequest } from '../contract/index.js';
 import type { ContentBlock } from '../core/agent-runner.ts';
 import { type Skill } from '../skills.ts';
-import { type WorkerNoMaterializationProof } from '../delegation/workspace.ts';
-import type { QueuedMessage, RunRecord, RunStore } from '../runs/store.ts';
+import { type QueuedMessage, type RunRecord, type RunStore } from '../runs/store.ts';
 import { WorkspaceSemaphore, type AccountHolds } from '../workspace/semaphore.ts';
+import type { UiEvent } from '../core/ui-events.ts';
 import { type WorkflowDef } from './types.ts';
 /** An interactive session that hears nothing from the user closes itself. */
 export declare const IDLE_TIMEOUT_MS: number;
@@ -18,12 +20,12 @@ export declare const IDLE_TIMEOUT_MS: number;
  * trailing `CEZ:TITLE=` block from absorbing later commentary (#623).
  */
 export declare function appendTurnText(current: string, next: string): string;
+export type TurnTail = 'none' | 'visible' | 'silent';
+/** Last top-level completed item: a non-empty assistant message is a visible tail; reasoning or a tool is silent even after earlier visible text (#544). An empty turn stays `none` and never nudges. */
+export declare function trackTurnTail(tail: TurnTail, event: UiEvent): TurnTail;
 /** Periodic "cezar autosave" commit in the task worktree (spec 006). */
 export declare const AUTOSAVE_INTERVAL_MS = 90000;
-/** Stop on a workflow check: SIGTERM first, SIGKILL to its process group after this grace. */
-export declare const CHECK_KILL_GRACE_MS = 3000;
-/** After SIGKILL, how long to wait for the group to disappear before resolving unconfirmed. */
-export declare const CHECK_TERMINATION_CONFIRM_MS = 5000;
+export { CHECK_KILL_GRACE_MS, CHECK_TERMINATION_CONFIRM_MS } from './grouped-command.ts';
 /** The periodic autosave timer is opt-in (#471): off, a task branch carries only the
  *  agent's own commits plus the turn-end/pre-PR flushes — no mid-run "cezar autosave"
  *  noise interleaving PR history. The flushes (`autosaveCommit` at turn end and before
@@ -49,10 +51,35 @@ export type DelegationExecutionSettings = {
     allowedTools?: string[];
     bashAllowlist?: string[];
 };
-/** Safety cap on autonomous auto-continues per run — stops a stuck agent from nudging forever. */
+/** What a Continue may carry (`RunManager.continueRun`). */
+type ContinueRunOptions = {
+    text?: string;
+    images?: PastedContent[];
+    runner?: RunnerId;
+    /** Internal configured fallback for an untouched workflow, resolved by the route. */
+    originalRunner?: RunnerId;
+    model?: string;
+    /** Reasoning-effort pin (#45). Omitted keeps the run's pin; empty string clears it. */
+    effort?: string;
+    /** Agent account for the reopened session (spec 2026-07-29-agent-profiles). Omitted = the
+     *  account the run is already on. */
+    agentProfile?: string;
+    /** #505: the parent reply this continuation delivers as the answer to a routed question. */
+    answerInputId?: string;
+};
 /** #505: a real steer is read at the harness's next model step; a quiet boundary this long
  * with input still unread means the harness will not read it without help. */
 export declare const UNREAD_INPUT_GRACE_MS = 30000;
+/** #486: recheck a turn-end that deferred close/park only because the harness still held a human follow-up. */
+export declare const HELD_HUMAN_INPUT_RECHECK_MS = 250;
+/** Bound a final-message nudge that is ACKed but never produces a turn (#544).
+ *  OpenCode heartbeats re-arm the managed-session no-progress guard, so this is
+ *  the DEFAULT-path exit when the agent stays silent. Overridable on RunManager. */
+export declare const FINAL_MESSAGE_NUDGE_REPLY_MS: number;
+/** Bound one unattended session; an explicit Continue starts a new budget. */
+export declare const MAX_AUTO_CONTINUES = 40;
+export declare const AUTONOMOUS_NUDGE = "Continue working autonomously until the task is fully complete. Do not ask me for confirmation or clarification \u2014 make reasonable assumptions and proceed. When everything is done, end the session with your done signal.";
+export declare const FINAL_MESSAGE_NUDGE = "Your last turn ended without a message to the user. Write your user-facing reply now: what you did, where things stand, and anything you need from the user. If the task goal is fully achieved, end that message with CEZ:DONE.";
 /**
  * Auto-resume after a provider usage limit (spec 2026-08-03-auto-resume-after-usage-limit).
  *
@@ -119,9 +146,8 @@ export interface StartRunInput {
      *  working tree instead of an isolated worktree. Undefined/`true` keeps the
      *  default per-task worktree. Ignored for variants (they always isolate). */
     worktree?: boolean;
-    /** Autonomous mode (#autonomous): the run never parks at `waiting` for the
-     *  user — turn-ends auto-continue until the agent signals done or the safety
-     *  cap is hit. No "needs you" is ever raised. */
+    /** Autonomous mode (#autonomous): eligible turn ends auto-continue until done
+     *  or the safety cap. Native asks, input delivery and lifecycle waits still apply. */
     autonomous?: boolean;
     /** Task webhook opt-in (#589). Persisted on the record at creation; read from there after. */
     notify?: boolean;
@@ -269,28 +295,34 @@ export declare class RunManager {
      * manager holds the run); `unknown` is a present record that proves nothing. */
     private orphanState;
     private orphanedWorkerGeneration;
-    /** Completes a crashed generation's proof once every one of its processes is proven gone (#469).
-     * Sync and signal-free; recovery, resume, delivery, collect and destroy then take their normal paths.
+    /** Settles a crashed generation after exit proof. Sync and signal-free; recovery, resume,
+     * delivery, collect and destroy then take their normal paths.
      * A non-gone probe is cached briefly: on darwin the scan is a synchronous `lsof` on the event loop. */
     settleOrphanedWorkerExecution(runId: string, opts?: {
         admitting?: boolean;
         fresh?: boolean;
+        cwds?: CwdSource;
     }): boolean;
     private readonly orphanProbes;
-    private readonly orphanReprobes;
+    /** Pending orphan reprobes by run id. One timer serves them all (hearsay-tools/cezarion#879). */
+    private readonly orphanDue;
+    private orphanTimer?;
+    /** The `at` the timer was armed for; with the clock, it decides what a tick takes. */
+    private orphanArmedFor;
     private readonly orphanBlockers;
     private readonly reportedOrphanBlockers;
-    private orphanReprobeMs;
-    private orphanReprobeLimitMs;
-    private orphanReprobeSlowMs;
+    private orphanBackoff;
     private orphanTermGraceMs;
     /** #469: a survivor that dies after recovery has no other wake source (no exit callback for a
      * process another cezar spawned). Unref'd; finalization's `run` event then lets worker waits and
-     * outcomes observe it. Fast for the first window, then slow but uncapped, so a long-lived
-     * survivor is still noticed when it exits. A tick while this manager holds the run is skipped;
-     * only terminal reasons (proof settled, generation changed, run gone, unknown record, dispose)
-     * stop it. */
+     * outcomes observe it. Every 15 s for the first 15 minutes, then backing off to hourly
+     * (hearsay-tools/cezarion#879), so a long-lived survivor is still noticed when it exits. One
+     * timer serves every orphan, and a tick shares one `/proc` scan across them. A tick while this
+     * manager holds the run is skipped; only terminal reasons (proof settled, generation changed,
+     * run gone, unknown record, dispose) stop it. */
     private armOrphanReprobe;
+    private wakeOrphanReprobes;
+    private orphanReprobeTick;
     private clearOrphanReprobe;
     /** Why the last destroy could not prove termination (#469), and whether that differs from the
      * reason last reported, so a retry loop appends one lifecycle event per distinct blocker set. */
@@ -303,6 +335,16 @@ export declare class RunManager {
     /** Destroy only (#469): signal the recorded, token-verified survivors of a generation whose
      * controller is proven dead, then finalize on `gone`. Scan-only processes are never signalled. */
     private reapOrphanedWorker;
+    /** Destroy only: SIGTERM recorded survivors, then SIGKILL what outlives `orphanTermGraceMs`.
+     * `pids` are signalled by token-verified pid; `groups` are session leaders whose whole process
+     * group is signalled (hearsay-tools/cezarion#890), so what an agent left behind exits with it. A
+     * dead leader's group counts only while a process holding `paths` is in it. Every signal
+     * re-verifies first: a reused PID or group number is never touched. */
+    private terminateRecorded;
+    /** Destroy of a finished generation (hearsay-tools/cezarion#890): a dev server or watcher its
+     * agent left in its process group holds the worktree, and nothing else ties it to the worker.
+     * A record whose controller is another live cezar is not ours to act on. */
+    private terminateFinishedWorkerGroups;
     /** Best effort: a failed write leaves the working-directory scan as this process's evidence. */
     private recordWorkerProcess;
     private trackTurnEnd;
@@ -310,9 +352,7 @@ export declare class RunManager {
     awaitRunTermination(runId: string, timeoutMs: number, opts?: {
         reapOrphans?: boolean;
     }): Promise<boolean>;
-    /** Private cleanup capability, never serialized. Obtain after stop/termination
-     * under the service's destroy lock; each invocation rechecks the same generation. */
-    getWorkerNoMaterializationProof(runId: string): WorkerNoMaterializationProof | undefined;
+    private proveRunTermination;
     /** Irreversible history removal is an execution tombstone, including for legacy children. */
     private historyDeletionPending;
     private workerExecutionStopped;
@@ -330,6 +370,12 @@ export declare class RunManager {
     private readonly ciRegistrations;
     private readonly ciRetries;
     private readonly ciResources;
+    /** #781: the workspace-wide preview host. Absent (`cez run`, tests) means every registration is `headless`. */
+    private readonly preview?;
+    /** The same host, for a removal outside this manager that must release a run's preview first. */
+    get previewHost(): PreviewHostLike | undefined;
+    /** #781: cezar's own listening port, which no dev server may register. */
+    private readonly cezarPort?;
     private ciSupervisor;
     private readonly workerWaiting;
     private readonly workerWakeAdmitted;
@@ -339,16 +385,37 @@ export declare class RunManager {
     private reconcilingWorkers;
     private reconcilingFamily;
     private readonly pendingReconciliations;
-    private recovering;
+    /** What the recovery in progress covers: every run at boot (`family` undefined), or the one
+     *  family an adoption hands it (#779, plan step 3). Undefined: no recovery in progress. */
+    private recoveryScope;
+    /** Settles when the recovery in progress (if any) has finished. */
+    private recoveryInFlight;
+    /** Adoptions of dead processes' runs, one at a time (`adoptOrphanedRun`). */
+    private adoptionTail;
     /** Quiet window before unread input is resubmitted or left unconfirmed (#505). */
     private readonly unreadInputGraceMs;
+    /** Quiet window after a final-message nudge before a still-silent session parks (#544). */
+    private readonly finalMessageNudgeReplyMs;
     private disposed;
+    /** Whether any recovery is in progress: one at a time (`recover`), and `pump` waits for it. */
+    private get recovering();
+    /**
+     * Whether a recovery in progress holds this run, so its wakes, input flushes and delegation
+     * reconciles wait for that recovery's own passes: every run during boot recovery, and only the
+     * adopted family's during a recovery scoped to one. The rest of a running project stays live: a
+     * wake held back for an unrelated family would be lost, since the scoped passes never revisit it.
+     */
+    private recoveringRun;
     private readonly onDelegationRun;
     private readonly pendingJobs;
     /** Interrupted agent turns recovered after a process restart. Unlike an
      *  explicit user Continue, these are bulk scheduler work and must re-enter
      *  through `pump()` so both workspace and per-project caps are honored. */
     private readonly pendingContinuations;
+    /** Accepted Continues supersede in-flight settlement even before launch or after
+     * idle close. Retain these across dropActive/dispose so absence cannot look like
+     * the earlier execution again; disposal alone never revokes terminal intent. */
+    private readonly continuationGenerations;
     /** Per-run image counter behind `pasted-<n>` / `screenshot-<n>` (#472). Lives on
      *  the manager rather than the `ActiveRun` so a *queued* run — which has no
      *  `ActiveRun` at all — can persist attachments. Seeded lazily from disk. */
@@ -402,6 +469,9 @@ export declare class RunManager {
     constructor(store: RunStore, repoRoot: string, options?: {
         semaphore?: WorkspaceSemaphore;
         unreadInputGraceMs?: number;
+        finalMessageNudgeReplyMs?: number;
+        preview?: PreviewHostLike;
+        cezarPort?: () => number | undefined;
     });
     /**
      * Release everything this manager owns without touching run records
@@ -484,6 +554,12 @@ export declare class RunManager {
     private provisionSession;
     /** Provision the same capability and descriptor on every start, Continue and recovered launch. */
     private provisionCiSession;
+    stopPreviewServer(runId: string, request: PreviewStopRequest, signal?: AbortSignal): Promise<PreviewStopResult>;
+    /**
+     * #781: record a dev server the agent registered. One probe at registration becomes
+     * `answeredAtRegistration`; the run is re-validated after it, since the probe awaits.
+     */
+    registerPreviewServer(runId: string, request: PreviewServeRequest, signal?: AbortSignal): Promise<PreviewServeResult>;
     /** Trusted capability callbacks supply run identity; the model supplies only a PR and deadline. */
     registerCiWait(runId: string, request: CiWaitRequest, generation: string, capabilitySignal?: AbortSignal): Promise<CiWait>;
     private startCiWatch;
@@ -607,15 +683,49 @@ export declare class RunManager {
      *  - `running` → mark interrupted, then immediately resume the last agent
      *    session via the Continue path, pointing the agent at its handoff file.
      * Call once, before the server starts taking requests.
+     *
+     * With `familyRootId`, the same recovery for the one delegation family a dead process left
+     * behind, which `adoptOrphanedRun` has just loaded. Either way only runs this store owns are
+     * touched: another live process's runs are not in the live set, and the passes that read every
+     * worker or root skip their families (#779, plan step 3).
      */
-    recover(): Promise<void>;
+    recover(familyRootId?: string): Promise<void>;
+    /**
+     * Take over a run whose owning process is gone (#779, plan step 3): a control (Stop, Continue,
+     * archive…) reached a run `runOwnership` calls `orphaned`. Its family is claimed, its live runs
+     * are settled rather than resumed (`settleOrphanedRun`: interrupted, or cancelled before they
+     * began), and the family is recovered as a restart would, which repairs it but finds nothing live
+     * to resume. The control that follows then acts on a run this process now owns — rather than on
+     * a record nobody owns, a dead end until a restart — and only Continue starts agent work, with
+     * the user's own input. With `stop` the control is Stop, which the adoption carries out itself:
+     * `runId` ends cancelled, as an accepted Stop reads, rather than interrupted. False when a live
+     * process holds it after all (or it is gone): the control is refused as another process's.
+     * Adoptions run one at a time, after any recovery already in progress.
+     */
+    adoptOrphanedRun(runId: string, opts?: {
+        stop?: boolean;
+    }): Promise<boolean>;
     /** The persisted definition when it looks sane, else the catalog by name. */
     private reviveWorkflow;
     private isDisposedDelegatedRun;
     /** Shutdown is not completion. Explicit terminal controls retain their precedence. */
     private preserveRunAfterDisposal;
+    /**
+     * Register an executing run: the ONE way an `ActiveRun` enters `active`. Both construction
+     * sites (`execute` and `runContinuation`, which serves Continue and restart recovery) call it,
+     * so the store pins every run this manager executes (#779) — its record stays the held object
+     * every turn-end handler reads and writes until `dropActive` lets it go. A second site that set
+     * `active` directly would execute a run the store could evict mid-turn (the #811 shape).
+     */
+    private activate;
     /** Remove a run from the live registries — keeps `waiting ⊆ active`. */
     private dropActive;
+    private readonly workerScratchCleanup;
+    /** Project detach cancels autonomous cleanup; reattach reconstructs the durable intents. */
+    pauseWorkerCleanup(): void;
+    recoverWorkerCleanup(): void;
+    /** Hold off every admission path until destructive work (including async Git) completes. */
+    claimWorkerCleanup(runId: string): (() => void) | undefined;
     /** Scratch belongs to the task, not its current agent process (#515).
      * Terminal status alone is not process-exit proof: an active session or an
      * unfinished private worker generation must retain its files until exit. */
@@ -745,6 +855,14 @@ export declare class RunManager {
      * forced removal is deleting — nor a removal start under a session that was just admitted.
      */
     claimWorktreeReclaim(runId: string): (() => void) | null;
+    /**
+     * Hold `runIds` against Continue, reclaim, publish and branch cleanup here AND in every other
+     * cezar process for the length of an async operation (#779, plan step 3; PR #851 review). An
+     * ownership check alone is a moment: pinning claims each run's family, so another process
+     * cannot claim and Continue it while this one rematerializes, publishes or deletes. Null when
+     * any hold fails (another process took the claim first); nothing stays held then.
+     */
+    private holdForMaintenance;
     /**
      * Claim every run that owns a branch about to be deleted (issue 08 §B3), or null when any is in
      * use: live, queued, at the review gate, or already claimed. The classification that allowed the
@@ -913,7 +1031,23 @@ export declare class RunManager {
     private settleRequestedRootFinish;
     /** Request deadlines share the existing reconciliation timer registry, never a polling loop. */
     private reconcileConversations;
-    /** Authority and wait live on disk; these collections are admission/timer caches only. */
+    /** One delegation family: its root, then the root's direct workers (the store's
+     *  `parent_run_id` query). Workers cannot delegate, so this never recurses. */
+    private familyMembers;
+    /** Every member of every family with a live member, each once: the families the store holds
+     *  in memory (#779), which is where every delegation sweep that is not about one family looks. */
+    private liveFamilyMembers;
+    /**
+     * Recovery's full pass (#661): every family whose root carries a conversation — settled ones
+     * too, so a projection or outcome a crash interrupted is repaired — then every live family.
+     * Only roots with a conversation are read; a settled family without one has nothing to settle:
+     * every other repair the sweep makes on a finished member (a stale `wait`, a cancelled root's
+     * Finish intent) is a clause of `isLiveRecord`, so open already holds that family.
+     * Everything else asks `reconcileWorkerWaits()`, which covers the live families (#779).
+     */
+    reconcileAllWorkerFamilies(): void;
+    /** Authority and wait live on disk; these collections are admission/timer caches only. One
+     *  family by its root's id, or (no id) every family with a live member. */
     reconcileWorkerWaits(familyRootId?: string): void;
     private reconcileWorkerFamily;
     queueWorkerWake(parentId: string): void;
@@ -958,8 +1092,13 @@ export declare class RunManager {
      * input is resubmitted once; after a second it is left delivered but unconfirmed. */
     private armUnreadInputTimer;
     private clearUnreadInputTimer;
+    /** #486: a turn-end deferred close/park only because the harness still held a human follow-up. */
+    private armHeldHumanInputTimer;
+    private clearHeldHumanInputTimer;
     /** #505: the harness accepted input this session has not reported reading yet. */
     private harnessOwesInput;
+    /** #486: a human follow-up is still queued in the live session and will still be delivered. */
+    private harnessHoldsHumanInput;
     /** A callback from an old/replaced/disposed session carries no authority. */
     private handleAgentInputReady;
     /** Reservation is synchronous; only an acknowledged transport may checkpoint delivery. */
@@ -992,6 +1131,9 @@ export declare class RunManager {
      * original workflow still has steps after the waiting one, that would skip
      * those steps rather than resume the workflow engine. */
     private waitingBeforeFinalWorkflowStep;
+    /** A clean process exit cannot complete a workflow still blocked on a question.
+     * Keep its existing durable waiting step so Continue can resume the tail. */
+    private unansweredWorkflowAsk;
     /** Locate the original workflow step whose closed session a synthetic Continue is resuming. */
     private waitingWorkflowStepIndex;
     /**
@@ -1005,27 +1147,14 @@ export declare class RunManager {
      * behaves exactly like an interactive step: `waiting` after each turn,
      * messages via sendMessage, closed by finish/idle/cancel.
      */
-    continueRun(runId: string, opts?: {
-        text?: string;
-        images?: PastedContent[];
-        runner?: RunnerId;
-        /** Internal configured fallback for an untouched workflow, resolved by the route. */
-        originalRunner?: RunnerId;
-        model?: string;
-        /** Reasoning-effort pin (#45). Omitted keeps the run's pin; empty string clears it. */
-        effort?: string;
-        /** Agent account for the reopened session (spec 2026-07-29-agent-profiles). Omitted = the
-         *  account the run is already on. */
-        agentProfile?: string;
-        /** #505: the parent reply this continuation delivers as the answer to a routed question. */
-        answerInputId?: string;
-    }, 
+    continueRun(runId: string, opts?: ContinueRunOptions, 
     /** Restart recovery may discover several interrupted tasks at once. Those
      *  continuations are queued; an explicit user Continue remains immediate. */
     deferForCapacity?: boolean, conversation?: Parameters<RunStore['commitWorkerContinuation']>[3]): {
         ok: boolean;
         error?: string;
     };
+    private admitContinuation;
     private runContinuation;
     private execute;
     /** Returns an error message, or null on success. */
@@ -1046,6 +1175,10 @@ export declare class RunManager {
     /** Ask precedence also releases an admitted but not yet delivered worker wake.
      * Its durable input/wait remain queued until an actual human answer. */
     private prepareHumanAsk;
+    /** A prose or rejected-ASK fallback supersedes a registered autonomous wait. Keep the
+     * checkpoint through idle closure/restart and hold worker input until a
+     * successful human delivery, just as for a structured ask. */
+    private prepareProseHumanGate;
     /** Native backend asks arrive before turn-end. Persist and park immediately
      * so the cockpit shows attention and the run releases its workspace slot. */
     private handleRunnerUiEvent;
@@ -1124,6 +1257,10 @@ export declare class RunManager {
      * off — settle straight to `done`, leaving the diff in the worktree untouched.
      */
     private settleSuccess;
+    /** Called only after session/process settlement. A refused nudge retained its
+     * slot and running status until idle close; ordinary roots must now become
+     * resumable. Previously parked roots and delegated lifecycle policy stay intact. */
+    private settleIdleClosedRun;
     /** An ordinary owned worker cannot accept an inactive Continue. Once its
      * idle-closed process has ended, publish the same terminal outcome recovery
      * would produce so its parent can collect it. Explicit asks and worker waits
@@ -1149,6 +1286,41 @@ export declare class RunManager {
      * shows the tool result's `[screenshot]` placeholder (or the image count).
      */
     private persistAttachment;
+    /** Shared stop/input/liveness guards for an automatic continuation. */
+    private canAutoContinue;
+    /**
+     * Both turn-end paths keep a nudged session running, with no user-wait timer or
+     * released slot. The next turn can finish with DONE, nudge again, or park at the
+     * cap (waiting/monitoring with their existing wake/idle rules). Queued/accepted
+     * input, worker/CI waits and parent completion keep priority. Cancel, Finish,
+     * disposal and memory pause stop nudging; provider errors/exits use normal
+     * teardown. Native mid-turn asks still park for an answer (outside this policy).
+     * A refused ordinary nudge waits for readiness at this exact boundary; the idle
+     * timeout bounds a missing readiness signal. New activity/input invalidates it.
+     * A refused portable override falls back to normal question parking.
+     */
+    private tryAutonomousNudge;
+    /** Shared silent-tail conditions for the one-shot visible-message nudge. Callers must
+     *  invoke this only when nothing else already continued. */
+    private maybeFinalMessageNudge;
+    /** One-shot visible-message nudge when a turn ends on reasoning or a tool (#544, #119).
+     *  Liveness: this path has no inputIds, so #505's unread-input timer does not apply, and
+     *  resumeParkedRun / clearIdleTimer drop the user-wait idle bound. Do not re-arm idle until
+     *  content arrives — some harnesses omit `turn.started` and still run (N8); idle would then
+     *  kill a live turn. OpenCode heartbeats re-arm the managed-session no-progress guard without
+     *  opening a turn, so an ACK that stays silent is bounded by FINAL_MESSAGE_NUDGE_REPLY_MS:
+     *  parent-level v1 content (text, tool-call, tool-result) and UiEvent items count at any time,
+     *  including before the timer is armed; `turn.started` counts after arm or while
+     *  `finalMessageNudgeParked` matches the session (OpenCode/Cursor emit a synthetic one inside
+     *  sendAgentMessage). Nested `item.*` with `parentItemId` is ignored.
+     *  Expiry parks `waiting` and latches `finalMessageNudgeParked`; a late reply from that session
+     *  resumes. User-authored delivery resets the one-shot latch; expiry does not. */
+    private tryFinalMessageNudge;
+    /** Heartbeats and nested subagent items are not a reply. OpenCode/Cursor synthetic `turn.started` inside `sendAgentMessage` cannot false-resume after expiry because a later send goes through `submitAgentInput` → `resumeParkedRun`. */
+    private isFinalMessageNudgeReply;
+    private noteFinalMessageNudgeContent;
+    private armFinalMessageNudgeReplyTimer;
+    private clearFinalMessageNudgeReplyTimer;
     private armIdleTimer;
     private clearIdleTimer;
     private reconcileMonitoringWakeTimers;
@@ -1160,6 +1332,15 @@ export declare class RunManager {
      *  Opt-in via CEZ_AUTOSAVE=1 (#471) — see periodicAutosaveEnabled. */
     private armAutosave;
     private clearAutosaveTimer;
+    /**
+     * Worktree setup (#917, spec `.ai/specs/2026-10-07-worktree-setup.md`): run the project's
+     * `worktreeSetup` commands in this run's isolated worktree when it needs them, and return the
+     * paragraph for the agent's opening message. `start` is a new task or worker, `rematerialized`
+     * a Continue that rebuilt a reclaimed directory, and `resume` any other Continue, which only
+     * finishes a setup a restart interrupted. In-place and non-Git runs never get setup: that tree
+     * is the user's own checkout.
+     */
+    private prepareWorktree;
     private runCheckStep;
     private finishStep;
 }