@wjarka/cezarion 0.16.0 → 0.17.0

package/dist/runs/store.d.ts

@@ -1,23 +1,18 @@
 import { EventEmitter } from 'node:events';
 import { type WorkerExecution } from './worker-execution.ts';
 import { z } from 'zod';
-import type { ArchiveFinishedScope, ArchivedRunsResponse, CiWait, ConversationState, AgentInput, InboxClaim, DelegationState, RunSummary, WorkerCollectedResult, WorkerDestroyRetry } from '../contract/index.js';
+import { queuedMessageSchema } from '../contract/index.js';
+import type { ArchiveFinishedScope, ArchivedRunsResponse, ArchivePullRequestIdentity, CiWait, PrWaitEntry, ConversationState, AgentInput, InboxClaim, DelegationState, MergedPullRequest, RunSummary, Wait, WorkerCollectedResult, WorkerDestroyRetry, WorkerWait, WorkerWaitEntry } from '../contract/index.js';
+import { type AutomationNames } from '../contract/index.js';
 import { type TranscriptFacts } from './transcript-facts.ts';
 import { type WorkerExecutionIdentity } from '../delegation/execution-identity.ts';
 import { type CwdSource, type WorkerProcessRecord } from '../delegation/process-liveness.ts';
 import { workflowDefSchema } from '../workflows/types.ts';
+import { type OutcomeDependencies, type RunOutcome } from './outcome-commit.ts';
+import { type RunnerId } from '../core/agent-runner.ts';
 import { type RawExtras } from './raw-record.ts';
 import { RunStoreOpenError } from './store-open-error.ts';
-import type { RunnerId } from '../core/agent-runner.ts';
 export type RunStatus = 'queued' | 'running' | 'waiting' | 'review' | 'done' | 'failed' | 'cancelled';
-/**
- * A sub-state of `running` (spec 2026-07-18-subagent-monitoring-status, #490):
- * the agent ended its turn still working on its own downstream work (a sub-agent
- * or a monitored command) and declared it with the `CEZ:MONITORING` marker — so
- * the cockpit shows a non-attention "monitoring" label instead of "needs you".
- * Only ever set while `status === 'running'`; cleared on resume/terminal.
- */
-export type RunActivity = 'monitoring';
 export type StepStatus = 'pending' | 'running' | 'waiting' | 'review' | 'done' | 'failed' | 'cancelled' | 'skipped';
 declare const stepStateSchema: z.ZodObject<{
     id: z.ZodString;
@@ -50,6 +45,13 @@ declare const stepStateSchema: z.ZodObject<{
     finishedAt: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
     sessionId: z.ZodOptional<z.ZodString>;
+    sessionTransport: z.ZodOptional<z.ZodEnum<{
+        "cursor-acp": "cursor-acp";
+        "cursor-print": "cursor-print";
+    }>>;
+    profileId: z.ZodOptional<z.ZodString>;
+    costUsd: z.ZodOptional<z.ZodNumber>;
+    synthetic: z.ZodOptional<z.ZodLiteral<"continuation">>;
     backend: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
         claude: "claude";
         "claude-cli": "claude-cli";
@@ -59,19 +61,6 @@ declare const stepStateSchema: z.ZodObject<{
         opencode: "opencode";
         pi: "pi";
     }>, z.ZodTransform<"claude" | "codex" | "cursor" | "omp" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "cursor" | "omp" | "opencode" | "pi">>>;
-    profileId: z.ZodOptional<z.ZodString>;
-    costUsd: z.ZodOptional<z.ZodNumber>;
-    synthetic: z.ZodOptional<z.ZodLiteral<"continuation">>;
-}, z.core.$strip>;
-/** One prompt message stacked onto a run while it waits for a free agent slot
- *  (#472). Folded into `{{task}}` at dequeue by `hydrateQueuedInput`; never
- *  delivered as its own turn — a follow-up turn would reach only the first step
- *  of a chain and would race the opening turn. */
-declare const queuedMessageSchema: z.ZodObject<{
-    id: z.ZodString;
-    text: z.ZodString;
-    images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    createdAt: z.ZodString;
 }, z.core.$strip>;
 /** Exported for `./run-index.ts`, the read-only reader of the same records. Nothing else should
  *  parse a stored run — see `reconcileLoadedRun` for why a second parser is a correctness risk. */
@@ -103,133 +92,837 @@ export declare const runRecordSchema: z.ZodObject<{
             lifecycle: "lifecycle";
         }>>;
         agentInputId: z.ZodOptional<z.ZodUUID>;
+        resumeContext: z.ZodOptional<z.ZodObject<{
+            failure: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodOptional<z.ZodString>;
+                error: z.ZodString;
+            }, z.core.$strip>>;
+            restarted: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
+    workflowResumeStepId: z.ZodOptional<z.ZodString>;
     invalidAsk: z.ZodOptional<z.ZodBoolean>;
-    delegation: z.ZodCatch<z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        role: z.ZodLiteral<"root">;
+    agentInputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
         conversation: z.ZodOptional<z.ZodObject<{
-            messages: z.ZodArray<z.ZodObject<{
-                senderRunId: z.ZodUUID;
-                recipientRunId: z.ZodUUID;
-                kind: z.ZodEnum<{
-                    "follow-up": "follow-up";
-                    progress: "progress";
-                    reply: "reply";
-                    request: "request";
-                }>;
-                requestId: z.ZodOptional<z.ZodUUID>;
-                id: z.ZodUUID;
-                text: z.ZodString;
-                createdAt: z.ZodISODateTime;
-                deadline: z.ZodOptional<z.ZodISODateTime>;
-                requestHash: z.ZodString;
-                state: z.ZodEnum<{
-                    accepted: "accepted";
-                    "continuation-required": "continuation-required";
-                    destroyed: "destroyed";
-                    late: "late";
-                }>;
-                resumed: z.ZodOptional<z.ZodLiteral<true>>;
-                instruction: z.ZodOptional<z.ZodString>;
-                question: z.ZodOptional<z.ZodObject<{
-                    questions: z.ZodArray<z.ZodObject<{
-                        id: z.ZodOptional<z.ZodString>;
-                        header: z.ZodString;
-                        question: z.ZodString;
-                        options: z.ZodArray<z.ZodObject<{
-                            label: z.ZodString;
-                            description: z.ZodOptional<z.ZodString>;
-                        }, z.core.$strict>>;
-                        multiSelect: z.ZodOptional<z.ZodBoolean>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-            outcomes: z.ZodArray<z.ZodObject<{
-                requestId: z.ZodUUID;
-                status: z.ZodEnum<{
-                    cancelled: "cancelled";
-                    "completed-without-reply": "completed-without-reply";
-                    destroyed: "destroyed";
-                    failed: "failed";
-                    "human-fallback": "human-fallback";
-                    replied: "replied";
-                    "sender-closed": "sender-closed";
-                    "timed-out": "timed-out";
-                }>;
-                observedAt: z.ZodISODateTime;
-                replyId: z.ZodOptional<z.ZodUUID>;
-            }, z.core.$strict>>;
+            senderRunId: z.ZodUUID;
+            recipientRunId: z.ZodUUID;
+            kind: z.ZodEnum<{
+                "follow-up": "follow-up";
+                progress: "progress";
+                reply: "reply";
+                request: "request";
+            }>;
+            requestId: z.ZodOptional<z.ZodUUID>;
         }, z.core.$strict>>;
-        permissions: z.ZodArray<z.ZodEnum<{
-            destroy: "destroy";
-            diff: "diff";
-            inspect: "inspect";
-            spawn: "spawn";
-            steer: "steer";
-            stop: "stop";
-            wait: "wait";
-        }>>;
-        receipts: z.ZodArray<z.ZodObject<{
-            requestId: z.ZodUUID;
-            workerId: z.ZodUUID;
-            requestHash: z.ZodString;
-            deletion: z.ZodOptional<z.ZodObject<{
-                phase: z.ZodEnum<{
-                    complete: "complete";
-                    pending: "pending";
-                }>;
-                revision: z.ZodNumber;
-                resourceId: z.ZodUUID;
-                generation: z.ZodUUID;
-            }, z.core.$strict>>;
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            lifecycle: "lifecycle";
+        }>;
+        parentRunId: z.ZodUUID;
+        text: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        consumedAt: z.ZodOptional<z.ZodISODateTime>;
+        awaitingRead: z.ZodOptional<z.ZodLiteral<true>>;
+        inboxClaim: z.ZodOptional<z.ZodObject<{
+            receiptId: z.ZodUUID;
+            generation: z.ZodUUID;
+            expiresAt: z.ZodISODateTime;
+            acknowledgedAt: z.ZodOptional<z.ZodISODateTime>;
+            memberIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
         }, z.core.$strict>>;
-        wait: z.ZodOptional<z.ZodObject<{
-            id: z.ZodUUID;
-            workerIds: z.ZodArray<z.ZodUUID>;
-            requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-            requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                requestId: z.ZodUUID;
-                status: z.ZodEnum<{
-                    cancelled: "cancelled";
-                    "completed-without-reply": "completed-without-reply";
-                    destroyed: "destroyed";
-                    failed: "failed";
-                    "human-fallback": "human-fallback";
-                    replied: "replied";
-                    "sender-closed": "sender-closed";
-                    "timed-out": "timed-out";
-                }>;
-                observedAt: z.ZodISODateTime;
-                replyId: z.ZodOptional<z.ZodUUID>;
-            }, z.core.$strict>>>;
-            deadline: z.ZodISODateTime;
-            mode: z.ZodOptional<z.ZodEnum<{
-                all: "all";
-                any: "any";
-                one: "one";
+        purpose: z.ZodOptional<z.ZodLiteral<"completion-refusal">>;
+    }, z.core.$strict>>>;
+    waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        prUrl: z.ZodString;
+        repository: z.ZodString;
+        prNumber: z.ZodNumber;
+        headSha: z.ZodString;
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"pr">;
+        deadline: z.ZodISODateTime;
+        generation: z.ZodString;
+        timeoutSeconds: z.ZodNumber;
+        until: z.ZodEnum<{
+            checks: "checks";
+            merge: "merge";
+        }>;
+        wakeOnConflict: z.ZodBoolean;
+        result: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                cancelled: "cancelled";
+                closed: "closed";
+                conflicting: "conflicting";
+                deadline: "deadline";
+                error: "error";
+                failed: "failed";
+                head_changed: "head_changed";
+                merged: "merged";
+                no_checks: "no_checks";
+                passed: "passed";
+                skipped: "skipped";
+            }>;
+            headSha: z.ZodString;
+            observedHeadSha: z.ZodOptional<z.ZodString>;
+            mergeable: z.ZodOptional<z.ZodEnum<{
+                CONFLICTING: "CONFLICTING";
+                MERGEABLE: "MERGEABLE";
+                UNKNOWN: "UNKNOWN";
             }>>;
-            revisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                workerId: z.ZodUUID;
-                revision: z.ZodNumber;
+            mergeStateStatus: z.ZodOptional<z.ZodString>;
+            mergedAt: z.ZodOptional<z.ZodISODateTime>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            observedAt: z.ZodISODateTime;
+            checks: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                state: z.ZodString;
+                link: z.ZodString;
+            }, z.core.$strict>>;
+            totalChecks: z.ZodNumber;
+            truncated: z.ZodBoolean;
+            diagnostic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"timer">;
+        deadline: z.ZodISODateTime;
+        seconds: z.ZodNumber;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+        questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            header: z.ZodString;
+            question: z.ZodString;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>>;
-            reason: z.ZodOptional<z.ZodEnum<{
+            multiSelect: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        context: z.ZodOptional<z.ZodString>;
+        askSeq: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"worker">;
+        deadline: z.ZodOptional<z.ZodISODateTime>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            any: "any";
+            one: "one";
+        }>>;
+        workerIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        revisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            workerId: z.ZodUUID;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>>;
+        outcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            workerId: z.ZodUUID;
+            status: z.ZodEnum<{
                 cancelled: "cancelled";
-                message: "message";
+                done: "done";
+                failed: "failed";
+                review: "review";
+            }>;
+            observedAt: z.ZodISODateTime;
+            summary: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            requestId: z.ZodUUID;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                "completed-without-reply": "completed-without-reply";
+                destroyed: "destroyed";
+                failed: "failed";
+                "human-fallback": "human-fallback";
+                replied: "replied";
+                "replied-late": "replied-late";
+                "sender-closed": "sender-closed";
+                "timed-out": "timed-out";
+            }>;
+            observedAt: z.ZodISODateTime;
+            replyId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>>>;
+        result: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodEnum<{
                 outcome: "outcome";
                 timeout: "timeout";
-            }>>;
-            phase: z.ZodEnum<{
-                parked: "parked";
-                registered: "registered";
-                "wake-pending": "wake-pending";
             }>;
-            outcomes: z.ZodArray<z.ZodObject<{
-                workerId: z.ZodUUID;
-                status: z.ZodEnum<{
-                    cancelled: "cancelled";
-                    done: "done";
-                    failed: "failed";
-                    review: "review";
+        }, z.core.$strict>>;
+        wakeInputId: z.ZodOptional<z.ZodUUID>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"process">;
+        deadline: z.ZodISODateTime;
+        timeoutSeconds: z.ZodNumber;
+        pid: z.ZodNumber;
+        startToken: z.ZodOptional<z.ZodString>;
+        exitFile: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                deadline: "deadline";
+                error: "error";
+                exit_file: "exit_file";
+                exited: "exited";
+            }>;
+            observedAt: z.ZodISODateTime;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            exitFileNote: z.ZodOptional<z.ZodLiteral<"not-an-exit-code">>;
+            diagnostic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>>;
+    lastWaits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        prUrl: z.ZodString;
+        repository: z.ZodString;
+        prNumber: z.ZodNumber;
+        headSha: z.ZodString;
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"pr">;
+        deadline: z.ZodISODateTime;
+        generation: z.ZodString;
+        timeoutSeconds: z.ZodNumber;
+        until: z.ZodEnum<{
+            checks: "checks";
+            merge: "merge";
+        }>;
+        wakeOnConflict: z.ZodBoolean;
+        result: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                cancelled: "cancelled";
+                closed: "closed";
+                conflicting: "conflicting";
+                deadline: "deadline";
+                error: "error";
+                failed: "failed";
+                head_changed: "head_changed";
+                merged: "merged";
+                no_checks: "no_checks";
+                passed: "passed";
+                skipped: "skipped";
+            }>;
+            headSha: z.ZodString;
+            observedHeadSha: z.ZodOptional<z.ZodString>;
+            mergeable: z.ZodOptional<z.ZodEnum<{
+                CONFLICTING: "CONFLICTING";
+                MERGEABLE: "MERGEABLE";
+                UNKNOWN: "UNKNOWN";
+            }>>;
+            mergeStateStatus: z.ZodOptional<z.ZodString>;
+            mergedAt: z.ZodOptional<z.ZodISODateTime>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            observedAt: z.ZodISODateTime;
+            checks: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                state: z.ZodString;
+                link: z.ZodString;
+            }, z.core.$strict>>;
+            totalChecks: z.ZodNumber;
+            truncated: z.ZodBoolean;
+            diagnostic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"timer">;
+        deadline: z.ZodISODateTime;
+        seconds: z.ZodNumber;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+        questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            header: z.ZodString;
+            question: z.ZodString;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            multiSelect: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        context: z.ZodOptional<z.ZodString>;
+        askSeq: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"worker">;
+        deadline: z.ZodOptional<z.ZodISODateTime>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            any: "any";
+            one: "one";
+        }>>;
+        workerIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        revisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            workerId: z.ZodUUID;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>>;
+        outcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            workerId: z.ZodUUID;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                done: "done";
+                failed: "failed";
+                review: "review";
+            }>;
+            observedAt: z.ZodISODateTime;
+            summary: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            requestId: z.ZodUUID;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                "completed-without-reply": "completed-without-reply";
+                destroyed: "destroyed";
+                failed: "failed";
+                "human-fallback": "human-fallback";
+                replied: "replied";
+                "replied-late": "replied-late";
+                "sender-closed": "sender-closed";
+                "timed-out": "timed-out";
+            }>;
+            observedAt: z.ZodISODateTime;
+            replyId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>>>;
+        result: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodEnum<{
+                outcome: "outcome";
+                timeout: "timeout";
+            }>;
+        }, z.core.$strict>>;
+        wakeInputId: z.ZodOptional<z.ZodUUID>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-worker-wait": "cez-worker-wait";
+            cezar_ask: "cezar_ask";
+            cezar_wait: "cezar_wait";
+            cezar_wait_for_ci: "cezar_wait_for_ci";
+            completion: "completion";
+            "monitoring-line": "monitoring-line";
+            "native-ask": "native-ask";
+            "no-wait": "no-wait";
+            "schedule-wakeup": "schedule-wakeup";
+        }>;
+        registeredAt: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+        turnId: z.ZodString;
+        kind: z.ZodLiteral<"process">;
+        deadline: z.ZodISODateTime;
+        timeoutSeconds: z.ZodNumber;
+        pid: z.ZodNumber;
+        startToken: z.ZodOptional<z.ZodString>;
+        exitFile: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                deadline: "deadline";
+                error: "error";
+                exit_file: "exit_file";
+                exited: "exited";
+            }>;
+            observedAt: z.ZodISODateTime;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            exitFileNote: z.ZodOptional<z.ZodLiteral<"not-an-exit-code">>;
+            diagnostic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>>;
+    previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        port: z.ZodNumber;
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        registeredAt: z.ZodISODateTime;
+        answeredAtRegistration: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    taskImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    modelIdentity: z.ZodOptional<z.ZodString>;
+    agentProfile: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    generateFollowups: z.ZodOptional<z.ZodBoolean>;
+    autonomous: z.ZodOptional<z.ZodBoolean>;
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
+    completionAction: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        phase: z.ZodEnum<{
+            blocked: "blocked";
+            complete: "complete";
+            pending: "pending";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    archiveBlocker: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        pullRequestUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        queued: "queued";
+        review: "review";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    createdAt: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    tokensUsed: z.ZodNumber;
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    costUsd: z.ZodOptional<z.ZodNumber>;
+    pullRequestUrl: z.ZodOptional<z.ZodString>;
+    referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
+    prNumber: z.ZodOptional<z.ZodNumber>;
+    issueNumber: z.ZodOptional<z.ZodNumber>;
+    referencedIssueNumberSeeded: z.ZodOptional<z.ZodBoolean>;
+    titleOrigin: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        marker: "marker";
+        user: "user";
+    }>>;
+    markerRefs: z.ZodOptional<z.ZodObject<{
+        pr: z.ZodOptional<z.ZodNumber>;
+        issue: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    referencedPrCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    referencedIssueUrl: z.ZodOptional<z.ZodString>;
+    referencedIssueCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    worktree: z.ZodOptional<z.ZodLiteral<false>>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    baseBranch: z.ZodOptional<z.ZodString>;
+    worktreeReclaimedAt: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
+    clientRequestId: z.ZodOptional<z.ZodString>;
+    clientRequestHash: z.ZodOptional<z.ZodString>;
+    peakRssBytes: z.ZodOptional<z.ZodNumber>;
+    peakProcCount: z.ZodOptional<z.ZodNumber>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    autoArchive: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodLiteral<"pull-requests-merged">;
+        archivedAt: z.ZodString;
+        fingerprint: z.ZodString;
+        pullRequests: z.ZodArray<z.ZodObject<{
+            owner: z.ZodString;
+            repo: z.ZodString;
+            number: z.ZodNumber;
+            mergedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    manualUnarchivedAt: z.ZodOptional<z.ZodString>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+    pinnedAt: z.ZodOptional<z.ZodString>;
+    seenAt: z.ZodOptional<z.ZodString>;
+    currentStepId: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    delegation: z.ZodCatch<z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        role: z.ZodLiteral<"root">;
+        conversation: z.ZodOptional<z.ZodObject<{
+            messages: z.ZodArray<z.ZodObject<{
+                senderRunId: z.ZodUUID;
+                recipientRunId: z.ZodUUID;
+                kind: z.ZodEnum<{
+                    "follow-up": "follow-up";
+                    progress: "progress";
+                    reply: "reply";
+                    request: "request";
+                }>;
+                requestId: z.ZodOptional<z.ZodUUID>;
+                id: z.ZodUUID;
+                text: z.ZodString;
+                createdAt: z.ZodISODateTime;
+                deadline: z.ZodOptional<z.ZodISODateTime>;
+                requestHash: z.ZodString;
+                state: z.ZodEnum<{
+                    accepted: "accepted";
+                    "continuation-required": "continuation-required";
+                    destroyed: "destroyed";
+                    late: "late";
+                }>;
+                resumed: z.ZodOptional<z.ZodLiteral<true>>;
+                instruction: z.ZodOptional<z.ZodString>;
+                question: z.ZodOptional<z.ZodObject<{
+                    context: z.ZodOptional<z.ZodString>;
+                    questions: z.ZodArray<z.ZodObject<{
+                        id: z.ZodOptional<z.ZodString>;
+                        header: z.ZodString;
+                        question: z.ZodString;
+                        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            label: z.ZodString;
+                            description: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>;
+                        multiSelect: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            outcomes: z.ZodArray<z.ZodObject<{
+                requestId: z.ZodUUID;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    "completed-without-reply": "completed-without-reply";
+                    destroyed: "destroyed";
+                    failed: "failed";
+                    "human-fallback": "human-fallback";
+                    replied: "replied";
+                    "replied-late": "replied-late";
+                    "sender-closed": "sender-closed";
+                    "timed-out": "timed-out";
+                }>;
+                observedAt: z.ZodISODateTime;
+                replyId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        permissions: z.ZodArray<z.ZodEnum<{
+            destroy: "destroy";
+            diff: "diff";
+            inspect: "inspect";
+            spawn: "spawn";
+            steer: "steer";
+            stop: "stop";
+            wait: "wait";
+        }>>;
+        receipts: z.ZodArray<z.ZodObject<{
+            requestId: z.ZodUUID;
+            workerId: z.ZodUUID;
+            requestHash: z.ZodString;
+            deletion: z.ZodOptional<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    complete: "complete";
+                    pending: "pending";
+                }>;
+                revision: z.ZodNumber;
+                resourceId: z.ZodUUID;
+                generation: z.ZodUUID;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        wait: z.ZodOptional<z.ZodObject<{
+            id: z.ZodUUID;
+            workerIds: z.ZodArray<z.ZodUUID>;
+            requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+            requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                requestId: z.ZodUUID;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    "completed-without-reply": "completed-without-reply";
+                    destroyed: "destroyed";
+                    failed: "failed";
+                    "human-fallback": "human-fallback";
+                    replied: "replied";
+                    "replied-late": "replied-late";
+                    "sender-closed": "sender-closed";
+                    "timed-out": "timed-out";
+                }>;
+                observedAt: z.ZodISODateTime;
+                replyId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>>>;
+            deadline: z.ZodISODateTime;
+            mode: z.ZodOptional<z.ZodEnum<{
+                all: "all";
+                any: "any";
+                one: "one";
+            }>>;
+            revisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                workerId: z.ZodUUID;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                message: "message";
+                outcome: "outcome";
+                timeout: "timeout";
+            }>>;
+            phase: z.ZodEnum<{
+                parked: "parked";
+                registered: "registered";
+                "wake-pending": "wake-pending";
+            }>;
+            outcomes: z.ZodArray<z.ZodObject<{
+                workerId: z.ZodUUID;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    done: "done";
+                    failed: "failed";
+                    review: "review";
                 }>;
                 observedAt: z.ZodISODateTime;
                 summary: z.ZodOptional<z.ZodString>;
@@ -250,6 +943,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -339,6 +1033,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -393,6 +1088,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -477,6 +1173,9 @@ export declare const runRecordSchema: z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"parent-attachment">;
                     id: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"parent-file">;
+                    path: z.ZodString;
                 }, z.core.$strict>], "kind">;
                 path: z.ZodString;
                 sha256: z.ZodString;
@@ -488,139 +1187,9 @@ export declare const runRecordSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         role: z.ZodLiteral<"invalid">;
     }, z.core.$strict>], "role">>>;
-    agentInputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        conversation: z.ZodOptional<z.ZodObject<{
-            senderRunId: z.ZodUUID;
-            recipientRunId: z.ZodUUID;
-            kind: z.ZodEnum<{
-                "follow-up": "follow-up";
-                progress: "progress";
-                reply: "reply";
-                request: "request";
-            }>;
-            requestId: z.ZodOptional<z.ZodUUID>;
-        }, z.core.$strict>>;
-        id: z.ZodUUID;
-        source: z.ZodEnum<{
-            agent: "agent";
-            lifecycle: "lifecycle";
-        }>;
-        parentRunId: z.ZodUUID;
-        text: z.ZodString;
-        createdAt: z.ZodISODateTime;
-        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-        consumedAt: z.ZodOptional<z.ZodISODateTime>;
-        awaitingRead: z.ZodOptional<z.ZodLiteral<true>>;
-        inboxClaim: z.ZodOptional<z.ZodObject<{
-            receiptId: z.ZodUUID;
-            generation: z.ZodUUID;
-            expiresAt: z.ZodISODateTime;
-            acknowledgedAt: z.ZodOptional<z.ZodISODateTime>;
-            memberIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>>;
-    ciWait: z.ZodOptional<z.ZodObject<{
-        prUrl: z.ZodString;
-        repository: z.ZodString;
-        prNumber: z.ZodNumber;
-        headSha: z.ZodString;
-        id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
-        registeredAt: z.ZodISODateTime;
-        deadline: z.ZodISODateTime;
-        phase: z.ZodEnum<{
-            delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
-        }>;
-        result: z.ZodOptional<z.ZodObject<{
-            outcome: z.ZodEnum<{
-                cancelled: "cancelled";
-                deadline: "deadline";
-                error: "error";
-                failed: "failed";
-                head_changed: "head_changed";
-                no_checks: "no_checks";
-                passed: "passed";
-                skipped: "skipped";
-            }>;
-            headSha: z.ZodString;
-            observedHeadSha: z.ZodOptional<z.ZodString>;
-            observedAt: z.ZodISODateTime;
-            checks: z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                state: z.ZodString;
-                link: z.ZodString;
-            }, z.core.$strict>>;
-            totalChecks: z.ZodNumber;
-            truncated: z.ZodBoolean;
-            diagnostic: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        wakeId: z.ZodOptional<z.ZodString>;
-        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-    }, z.core.$strict>>;
-    lastCiWait: z.ZodOptional<z.ZodObject<{
-        prUrl: z.ZodString;
-        repository: z.ZodString;
-        prNumber: z.ZodNumber;
-        headSha: z.ZodString;
-        id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
-        registeredAt: z.ZodISODateTime;
-        deadline: z.ZodISODateTime;
-        phase: z.ZodEnum<{
-            delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
-        }>;
-        result: z.ZodOptional<z.ZodObject<{
-            outcome: z.ZodEnum<{
-                cancelled: "cancelled";
-                deadline: "deadline";
-                error: "error";
-                failed: "failed";
-                head_changed: "head_changed";
-                no_checks: "no_checks";
-                passed: "passed";
-                skipped: "skipped";
-            }>;
-            headSha: z.ZodString;
-            observedHeadSha: z.ZodOptional<z.ZodString>;
-            observedAt: z.ZodISODateTime;
-            checks: z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                state: z.ZodString;
-                link: z.ZodString;
-            }, z.core.$strict>>;
-            totalChecks: z.ZodNumber;
-            truncated: z.ZodBoolean;
-            diagnostic: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        wakeId: z.ZodOptional<z.ZodString>;
-        deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-    }, z.core.$strict>>;
-    lastCiWaitError: z.ZodOptional<z.ZodString>;
-    previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        port: z.ZodNumber;
-        command: z.ZodString;
-        cwd: z.ZodOptional<z.ZodString>;
-        label: z.ZodString;
-        path: z.ZodOptional<z.ZodString>;
-        registeredAt: z.ZodISODateTime;
-        answeredAtRegistration: z.ZodBoolean;
-    }, z.core.$strip>>>;
-    taskImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    model: z.ZodOptional<z.ZodString>;
-    effort: z.ZodOptional<z.ZodString>;
-    modelIdentity: z.ZodOptional<z.ZodString>;
+    lastWaitsError: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    automaticWakes: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    waitDeliveryFailures: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
     runner: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
         claude: "claude";
         "claude-cli": "claude-cli";
@@ -630,85 +1199,29 @@ export declare const runRecordSchema: z.ZodObject<{
         opencode: "opencode";
         pi: "pi";
     }>, z.ZodTransform<"claude" | "codex" | "cursor" | "omp" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "cursor" | "omp" | "opencode" | "pi">>>;
-    agentProfile: z.ZodOptional<z.ZodString>;
-    systemPrompt: z.ZodOptional<z.ZodString>;
-    generateFollowups: z.ZodOptional<z.ZodBoolean>;
-    autonomous: z.ZodOptional<z.ZodBoolean>;
     notify: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     webhook: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         lastDeliveredAt: z.ZodOptional<z.ZodString>;
         lastError: z.ZodOptional<z.ZodString>;
+        lastErrorWebhookId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
-    automation: z.ZodOptional<z.ZodObject<{
-        automationId: z.ZodString;
-        automationRevision: z.ZodNumber;
-        receiptId: z.ZodString;
-        event: z.ZodString;
-        githubUrl: z.ZodString;
-    }, z.core.$strip>>;
-    automationTrigger: z.ZodOptional<z.ZodObject<{
-        automationId: z.ZodString;
-        automationRevision: z.ZodNumber;
-        receiptId: z.ZodString;
-        trigger: z.ZodEnum<{
-            "catch-up": "catch-up";
-            manual: "manual";
-            schedule: "schedule";
-        }>;
-        occurrenceAt: z.ZodString;
-    }, z.core.$strip>>;
     destroyRetry: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         attempts: z.ZodNumber;
         nextAt: z.ZodISODateTime;
         needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strict>>>;
-    status: z.ZodEnum<{
-        cancelled: "cancelled";
-        done: "done";
-        failed: "failed";
-        queued: "queued";
-        review: "review";
-        running: "running";
-        waiting: "waiting";
-    }>;
     stopping: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    activity: z.ZodOptional<z.ZodEnum<{
-        monitoring: "monitoring";
-    }>>;
-    hasPendingHumanAsk: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    monitoringWakeAt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    monitoringWakeCapReached: z.ZodOptional<z.ZodBoolean>;
+    hasPendingPermission: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     autoResumeAt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     autoResumeAttempts: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
-    createdAt: z.ZodString;
-    startedAt: z.ZodOptional<z.ZodString>;
-    finishedAt: z.ZodOptional<z.ZodString>;
-    tokensUsed: z.ZodNumber;
-    inputTokens: z.ZodOptional<z.ZodNumber>;
-    outputTokens: z.ZodOptional<z.ZodNumber>;
-    costUsd: z.ZodOptional<z.ZodNumber>;
-    pullRequestUrl: z.ZodOptional<z.ZodString>;
-    referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
-    prNumber: z.ZodOptional<z.ZodNumber>;
-    issueNumber: z.ZodOptional<z.ZodNumber>;
-    referencedIssueNumberSeeded: z.ZodOptional<z.ZodBoolean>;
-    titleOrigin: z.ZodOptional<z.ZodEnum<{
-        auto: "auto";
-        marker: "marker";
-        user: "user";
-    }>>;
-    markerRefs: z.ZodOptional<z.ZodObject<{
-        pr: z.ZodOptional<z.ZodNumber>;
-        issue: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    referencedPrCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    referencedIssueUrl: z.ZodOptional<z.ZodString>;
-    referencedIssueCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    worktree: z.ZodOptional<z.ZodLiteral<false>>;
-    worktreePath: z.ZodOptional<z.ZodString>;
-    branch: z.ZodOptional<z.ZodString>;
-    baseBranch: z.ZodOptional<z.ZodString>;
-    worktreeReclaimedAt: z.ZodOptional<z.ZodString>;
+    pullRequests: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        url: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            created: "created";
+            declared: "declared";
+        }>;
+    }, z.core.$strip>>>>;
     worktreeSetup: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             done: "done";
@@ -720,19 +1233,41 @@ export declare const runRecordSchema: z.ZodObject<{
         durationMs: z.ZodOptional<z.ZodNumber>;
         error: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
-    groupId: z.ZodOptional<z.ZodString>;
-    variant: z.ZodOptional<z.ZodString>;
-    clientRequestId: z.ZodOptional<z.ZodString>;
-    clientRequestHash: z.ZodOptional<z.ZodString>;
-    peakRssBytes: z.ZodOptional<z.ZodNumber>;
-    peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodDefault<z.ZodBoolean>;
-    archivedAt: z.ZodOptional<z.ZodString>;
-    pinned: z.ZodOptional<z.ZodBoolean>;
-    pinnedAt: z.ZodOptional<z.ZodString>;
-    seenAt: z.ZodOptional<z.ZodString>;
-    currentStepId: z.ZodOptional<z.ZodString>;
-    error: z.ZodOptional<z.ZodString>;
+    workflowDef: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            prompt: z.ZodOptional<z.ZodString>;
+            skill: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            runner: z.ZodOptional<z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+                cursor: "cursor";
+                omp: "omp";
+                opencode: "opencode";
+                pi: "pi";
+            }>>;
+            agentProfile: z.ZodOptional<z.ZodString>;
+            allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            bashAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            command: z.ZodOptional<z.ZodString>;
+            onFail: z.ZodOptional<z.ZodObject<{
+                retry: z.ZodString;
+                max: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        source: z.ZodEnum<{
+            "built-in": "built-in";
+            file: "file";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
     steps: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
@@ -764,6 +1299,13 @@ export declare const runRecordSchema: z.ZodObject<{
         finishedAt: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
         sessionId: z.ZodOptional<z.ZodString>;
+        sessionTransport: z.ZodOptional<z.ZodEnum<{
+            "cursor-acp": "cursor-acp";
+            "cursor-print": "cursor-print";
+        }>>;
+        profileId: z.ZodOptional<z.ZodString>;
+        costUsd: z.ZodOptional<z.ZodNumber>;
+        synthetic: z.ZodOptional<z.ZodLiteral<"continuation">>;
         backend: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
             claude: "claude";
             "claude-cli": "claude-cli";
@@ -773,46 +1315,64 @@ export declare const runRecordSchema: z.ZodObject<{
             opencode: "opencode";
             pi: "pi";
         }>, z.ZodTransform<"claude" | "codex" | "cursor" | "omp" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "cursor" | "omp" | "opencode" | "pi">>>;
-        profileId: z.ZodOptional<z.ZodString>;
-        costUsd: z.ZodOptional<z.ZodNumber>;
-        synthetic: z.ZodOptional<z.ZodLiteral<"continuation">>;
     }, z.core.$strip>>;
-    workflowDef: z.ZodCatch<z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        steps: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodOptional<z.ZodString>;
-            prompt: z.ZodOptional<z.ZodString>;
-            skill: z.ZodOptional<z.ZodString>;
-            model: z.ZodOptional<z.ZodString>;
-            effort: z.ZodOptional<z.ZodString>;
-            timeoutMs: z.ZodOptional<z.ZodNumber>;
-            runner: z.ZodOptional<z.ZodEnum<{
-                claude: "claude";
-                codex: "codex";
-                cursor: "cursor";
-                omp: "omp";
-                opencode: "opencode";
-                pi: "pi";
-            }>>;
-            agentProfile: z.ZodOptional<z.ZodString>;
-            allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            bashAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            command: z.ZodOptional<z.ZodString>;
-            onFail: z.ZodOptional<z.ZodObject<{
-                retry: z.ZodString;
-                max: z.ZodDefault<z.ZodNumber>;
+    automation: z.ZodOptional<z.ZodObject<{
+        automationId: z.ZodString;
+        receiptId: z.ZodString;
+        event: z.ZodString;
+        automationRevision: z.ZodNumber;
+        githubUrl: z.ZodString;
+    }, z.core.$strip>>;
+    automationTrigger: z.ZodOptional<z.ZodObject<{
+        automationId: z.ZodString;
+        receiptId: z.ZodString;
+        trigger: z.ZodEnum<{
+            "catch-up": "catch-up";
+            manual: "manual";
+            schedule: "schedule";
+        }>;
+        occurrenceAt: z.ZodString;
+        automationRevision: z.ZodNumber;
+    }, z.core.$strip>>;
+    handoffRecords: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        autosave: z.ZodArray<z.ZodObject<{
+            at: z.ZodString;
+            note: z.ZodString;
+            periodic: z.ZodOptional<z.ZodObject<{
+                branch: z.ZodNullable<z.ZodString>;
+                count: z.ZodNumber;
+                first: z.ZodNullable<z.ZodString>;
+                latest: z.ZodNullable<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
-        source: z.ZodEnum<{
-            "built-in": "built-in";
-            file: "file";
-        }>;
-        path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
-/** Salvage CI state identically for live stores and the read-only workspace index. */
+/** A legacy `CiWait` as a wait entry. Its wake input's id was the wait's own (`wakeId`, which
+ *  `run.ts` set to the wait id), so the entry keeps that id and delivery still finds the input. */
+export declare function ciWaitEntry(wait: CiWait): PrWaitEntry;
+/**
+ * A legacy agent `delegation.wait` as a worker wait entry (store schema 6, hearsay-tools/cezarion#1235),
+ * judged from the wait alone: what became of its wake input is `upgradeLegacyWaits`' to apply.
+ * `registered`/`parked` → open; `wake-pending` → resolved with its `outcome`/`timeout` reason, or
+ * cancelled. Undefined for the `message` stand-in, which was never an agent's wait: a message no
+ * longer resolves a wait, and its input still wakes the run on its own.
+ *
+ * Deterministic, never read from the clock: a row is upgraded on every read until open rewrites
+ * it, and two reads must agree. A `WorkerWait` kept no registration time, so `timeoutSeconds` is
+ * the 600 default, `registeredAt` is 600 s before the original deadline (kept as it was), and the
+ * settled stamps come from the wait itself: `resolvedAt` is the latest observation it holds, else
+ * its deadline, and `cancelledAt` is its deadline. `now` is only the fallback for a deadline that
+ * does not read, which the wait schema never admits.
+ */
+export declare function workerWaitEntry(wait: WorkerWait, now: string): WorkerWaitEntry | undefined;
+/** Whether a record is a root still parked on its workers: an open or resolved worker wait in the
+ *  list. Such a root has its pending human question re-read from the transcript before a manager
+ *  parks it. Every stored `delegation.wait`, the completion gate's included, is read into the list
+ *  on open (store schema 7, hearsay-tools/cezarion#1301), so the list is the only place to look. */
+export declare function holdsWorkerWait(run: Pick<RunRecord, 'delegation' | 'waits'>): boolean;
+export declare function upgradeLegacyWaits(row: Record<string, unknown>): void;
+/** Read legacy wait fields into the wait list and salvage per entry, identically for live stores
+ *  and the read-only workspace index. */
 export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
     id: string;
     title: string;
@@ -838,8 +1398,393 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
         createdAt: string;
         origin?: "human" | "lifecycle" | undefined;
         agentInputId?: string | undefined;
+        resumeContext?: {
+            failure?: {
+                stepId?: string | undefined;
+                error: string;
+            } | undefined;
+            restarted?: true | undefined;
+        } | undefined;
+    } | undefined;
+    workflowResumeStepId?: string | undefined;
+    invalidAsk?: boolean | undefined;
+    agentInputs?: {
+        conversation?: {
+            senderRunId: string;
+            recipientRunId: string;
+            kind: "follow-up" | "progress" | "reply" | "request";
+            requestId?: string | undefined;
+        } | undefined;
+        id: string;
+        source: "agent" | "lifecycle";
+        parentRunId: string;
+        text: string;
+        createdAt: string;
+        deliveredAt?: string | undefined;
+        consumedAt?: string | undefined;
+        awaitingRead?: true | undefined;
+        inboxClaim?: {
+            receiptId: string;
+            generation: string;
+            expiresAt: string;
+            acknowledgedAt?: string | undefined;
+            memberIds?: string[] | undefined;
+        } | undefined;
+        purpose?: "completion-refusal" | undefined;
+    }[] | undefined;
+    waits?: ({
+        prUrl: string;
+        repository: string;
+        prNumber: number;
+        headSha: string;
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "pr";
+        deadline: string;
+        generation: string;
+        timeoutSeconds: number;
+        until: "checks" | "merge";
+        wakeOnConflict: boolean;
+        result?: {
+            outcome: "cancelled" | "closed" | "conflicting" | "deadline" | "error" | "failed" | "head_changed" | "merged" | "no_checks" | "passed" | "skipped";
+            headSha: string;
+            observedHeadSha?: string | undefined;
+            mergeable?: "CONFLICTING" | "MERGEABLE" | "UNKNOWN" | undefined;
+            mergeStateStatus?: string | undefined;
+            mergedAt?: string | undefined;
+            mergeCommitSha?: string | undefined;
+            observedAt: string;
+            checks: {
+                name: string;
+                state: string;
+                link: string;
+            }[];
+            totalChecks: number;
+            truncated: boolean;
+            diagnostic?: string | undefined;
+        } | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "timer";
+        deadline: string;
+        seconds: number;
+        note?: string | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "human";
+        questions?: {
+            id?: string | undefined;
+            header: string;
+            question: string;
+            options?: {
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            multiSelect?: boolean | undefined;
+        }[] | undefined;
+        context?: string | undefined;
+        askSeq?: number | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "worker";
+        deadline?: string | undefined;
+        timeoutSeconds?: number | undefined;
+        mode?: "all" | "any" | "one" | undefined;
+        workerIds?: string[] | undefined;
+        revisions?: {
+            workerId: string;
+            revision: number;
+        }[] | undefined;
+        outcomes?: {
+            workerId: string;
+            status: "cancelled" | "done" | "failed" | "review";
+            observedAt: string;
+            summary?: string | undefined;
+            revision?: number | undefined;
+        }[] | undefined;
+        requestIds?: string[] | undefined;
+        requestOutcomes?: {
+            requestId: string;
+            status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
+            observedAt: string;
+            replyId?: string | undefined;
+        }[] | undefined;
+        result?: {
+            reason: "outcome" | "timeout";
+        } | undefined;
+        wakeInputId?: string | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "process";
+        deadline: string;
+        timeoutSeconds: number;
+        pid: number;
+        startToken?: string | undefined;
+        exitFile?: string | undefined;
+        note?: string | undefined;
+        result?: {
+            outcome: "deadline" | "error" | "exit_file" | "exited";
+            observedAt: string;
+            exitCode?: number | undefined;
+            exitFileNote?: "not-an-exit-code" | undefined;
+            diagnostic?: string | undefined;
+        } | undefined;
+    })[] | undefined;
+    lastWaits?: ({
+        prUrl: string;
+        repository: string;
+        prNumber: number;
+        headSha: string;
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "pr";
+        deadline: string;
+        generation: string;
+        timeoutSeconds: number;
+        until: "checks" | "merge";
+        wakeOnConflict: boolean;
+        result?: {
+            outcome: "cancelled" | "closed" | "conflicting" | "deadline" | "error" | "failed" | "head_changed" | "merged" | "no_checks" | "passed" | "skipped";
+            headSha: string;
+            observedHeadSha?: string | undefined;
+            mergeable?: "CONFLICTING" | "MERGEABLE" | "UNKNOWN" | undefined;
+            mergeStateStatus?: string | undefined;
+            mergedAt?: string | undefined;
+            mergeCommitSha?: string | undefined;
+            observedAt: string;
+            checks: {
+                name: string;
+                state: string;
+                link: string;
+            }[];
+            totalChecks: number;
+            truncated: boolean;
+            diagnostic?: string | undefined;
+        } | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "timer";
+        deadline: string;
+        seconds: number;
+        note?: string | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "human";
+        questions?: {
+            id?: string | undefined;
+            header: string;
+            question: string;
+            options?: {
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            multiSelect?: boolean | undefined;
+        }[] | undefined;
+        context?: string | undefined;
+        askSeq?: number | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "worker";
+        deadline?: string | undefined;
+        timeoutSeconds?: number | undefined;
+        mode?: "all" | "any" | "one" | undefined;
+        workerIds?: string[] | undefined;
+        revisions?: {
+            workerId: string;
+            revision: number;
+        }[] | undefined;
+        outcomes?: {
+            workerId: string;
+            status: "cancelled" | "done" | "failed" | "review";
+            observedAt: string;
+            summary?: string | undefined;
+            revision?: number | undefined;
+        }[] | undefined;
+        requestIds?: string[] | undefined;
+        requestOutcomes?: {
+            requestId: string;
+            status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
+            observedAt: string;
+            replyId?: string | undefined;
+        }[] | undefined;
+        result?: {
+            reason: "outcome" | "timeout";
+        } | undefined;
+        wakeInputId?: string | undefined;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "process";
+        deadline: string;
+        timeoutSeconds: number;
+        pid: number;
+        startToken?: string | undefined;
+        exitFile?: string | undefined;
+        note?: string | undefined;
+        result?: {
+            outcome: "deadline" | "error" | "exit_file" | "exited";
+            observedAt: string;
+            exitCode?: number | undefined;
+            exitFileNote?: "not-an-exit-code" | undefined;
+            diagnostic?: string | undefined;
+        } | undefined;
+    })[] | undefined;
+    previewServers?: {
+        port: number;
+        command: string;
+        cwd?: string | undefined;
+        label: string;
+        path?: string | undefined;
+        registeredAt: string;
+        answeredAtRegistration: boolean;
+    }[] | undefined;
+    taskImages?: string[] | undefined;
+    model?: string | undefined;
+    effort?: string | undefined;
+    modelIdentity?: string | undefined;
+    agentProfile?: string | undefined;
+    systemPrompt?: string | undefined;
+    generateFollowups?: boolean | undefined;
+    autonomous?: boolean | undefined;
+    archiveWhenDone?: boolean | undefined;
+    autoMergePr?: boolean | undefined;
+    completionAction?: {
+        id: string;
+        phase: "blocked" | "complete" | "pending";
+        message?: string | undefined;
+    } | undefined;
+    archiveBlocker?: {
+        message: string;
+        runId?: string | undefined;
+        pullRequestUrl?: string | undefined;
+    } | undefined;
+    status: "cancelled" | "done" | "failed" | "queued" | "review" | "running" | "waiting";
+    createdAt: string;
+    startedAt?: string | undefined;
+    finishedAt?: string | undefined;
+    tokensUsed: number;
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
+    costUsd?: number | undefined;
+    pullRequestUrl?: string | undefined;
+    referencedPullRequestUrl?: string | undefined;
+    prNumber?: number | undefined;
+    issueNumber?: number | undefined;
+    referencedIssueNumberSeeded?: boolean | undefined;
+    titleOrigin?: "auto" | "marker" | "user" | undefined;
+    markerRefs?: {
+        pr?: number | undefined;
+        issue?: number | undefined;
+    } | undefined;
+    referencedPrCandidates?: string[] | undefined;
+    referencedIssueUrl?: string | undefined;
+    referencedIssueCandidates?: string[] | undefined;
+    worktree?: false | undefined;
+    worktreePath?: string | undefined;
+    branch?: string | undefined;
+    baseBranch?: string | undefined;
+    worktreeReclaimedAt?: string | undefined;
+    groupId?: string | undefined;
+    variant?: string | undefined;
+    clientRequestId?: string | undefined;
+    clientRequestHash?: string | undefined;
+    peakRssBytes?: number | undefined;
+    peakProcCount?: number | undefined;
+    archivedAt?: string | undefined;
+    autoArchive?: {
+        reason: "pull-requests-merged";
+        archivedAt: string;
+        fingerprint: string;
+        pullRequests: {
+            owner: string;
+            repo: string;
+            number: number;
+            mergedAt: string;
+        }[];
     } | undefined;
-    invalidAsk?: boolean | undefined;
+    manualUnarchivedAt?: string | undefined;
+    pinned?: boolean | undefined;
+    pinnedAt?: string | undefined;
+    seenAt?: string | undefined;
+    currentStepId?: string | undefined;
+    error?: string | undefined;
     delegation?: {
         role: "root";
         conversation?: {
@@ -857,21 +1802,22 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
                 resumed?: true | undefined;
                 instruction?: string | undefined;
                 question?: {
+                    context?: string | undefined;
                     questions: {
                         id?: string | undefined;
                         header: string;
                         question: string;
-                        options: {
+                        options?: {
                             label: string;
                             description?: string | undefined;
-                        }[];
+                        }[] | undefined;
                         multiSelect?: boolean | undefined;
                     }[];
                 } | undefined;
             }[];
             outcomes: {
                 requestId: string;
-                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "sender-closed" | "timed-out";
+                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
                 observedAt: string;
                 replyId?: string | undefined;
             }[];
@@ -894,7 +1840,7 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
             requestIds?: string[] | undefined;
             requestOutcomes?: {
                 requestId: string;
-                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "sender-closed" | "timed-out";
+                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
                 observedAt: string;
                 replyId?: string | undefined;
             }[] | undefined;
@@ -921,7 +1867,7 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
             requestIds?: string[] | undefined;
             requestOutcomes?: {
                 requestId: string;
-                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "sender-closed" | "timed-out";
+                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
                 observedAt: string;
                 replyId?: string | undefined;
             }[] | undefined;
@@ -968,7 +1914,7 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
             requestIds?: string[] | undefined;
             requestOutcomes?: {
                 requestId: string;
-                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "sender-closed" | "timed-out";
+                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
                 observedAt: string;
                 replyId?: string | undefined;
             }[] | undefined;
@@ -995,7 +1941,7 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
             requestIds?: string[] | undefined;
             requestOutcomes?: {
                 requestId: string;
-                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "sender-closed" | "timed-out";
+                status: "cancelled" | "completed-without-reply" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
                 observedAt: string;
                 replyId?: string | undefined;
             }[] | undefined;
@@ -1036,6 +1982,9 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
             text?: string | undefined;
             inputs: {
                 source: {
+                    kind: "parent-file";
+                    path: string;
+                } | {
                     kind: "baseline-file";
                     path: string;
                 } | {
@@ -1052,163 +2001,30 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
     } | {
         role: "invalid";
     } | undefined;
-    agentInputs?: {
-        conversation?: {
-            senderRunId: string;
-            recipientRunId: string;
-            kind: "follow-up" | "progress" | "reply" | "request";
-            requestId?: string | undefined;
-        } | undefined;
-        id: string;
-        source: "agent" | "lifecycle";
-        parentRunId: string;
-        text: string;
-        createdAt: string;
-        deliveredAt?: string | undefined;
-        consumedAt?: string | undefined;
-        awaitingRead?: true | undefined;
-        inboxClaim?: {
-            receiptId: string;
-            generation: string;
-            expiresAt: string;
-            acknowledgedAt?: string | undefined;
-            memberIds?: string[] | undefined;
-        } | undefined;
-    }[] | undefined;
-    ciWait?: {
-        prUrl: string;
-        repository: string;
-        prNumber: number;
-        headSha: string;
-        id: string;
-        generation: string;
-        turnId: string;
-        timeoutSeconds: number;
-        registeredAt: string;
-        deadline: string;
-        phase: "delivered" | "parked" | "registered" | "wake-pending" | "withdrawn";
-        result?: {
-            outcome: "cancelled" | "deadline" | "error" | "failed" | "head_changed" | "no_checks" | "passed" | "skipped";
-            headSha: string;
-            observedHeadSha?: string | undefined;
-            observedAt: string;
-            checks: {
-                name: string;
-                state: string;
-                link: string;
-            }[];
-            totalChecks: number;
-            truncated: boolean;
-            diagnostic?: string | undefined;
-        } | undefined;
-        wakeId?: string | undefined;
-        deliveredAt?: string | undefined;
-    } | undefined;
-    lastCiWait?: {
-        prUrl: string;
-        repository: string;
-        prNumber: number;
-        headSha: string;
-        id: string;
-        generation: string;
-        turnId: string;
-        timeoutSeconds: number;
-        registeredAt: string;
-        deadline: string;
-        phase: "delivered" | "parked" | "registered" | "wake-pending" | "withdrawn";
-        result?: {
-            outcome: "cancelled" | "deadline" | "error" | "failed" | "head_changed" | "no_checks" | "passed" | "skipped";
-            headSha: string;
-            observedHeadSha?: string | undefined;
-            observedAt: string;
-            checks: {
-                name: string;
-                state: string;
-                link: string;
-            }[];
-            totalChecks: number;
-            truncated: boolean;
-            diagnostic?: string | undefined;
-        } | undefined;
-        wakeId?: string | undefined;
-        deliveredAt?: string | undefined;
-    } | undefined;
-    lastCiWaitError?: string | undefined;
-    previewServers?: {
-        port: number;
-        command: string;
-        cwd?: string | undefined;
-        label: string;
-        path?: string | undefined;
-        registeredAt: string;
-        answeredAtRegistration: boolean;
-    }[] | undefined;
-    taskImages?: string[] | undefined;
-    model?: string | undefined;
-    effort?: string | undefined;
-    modelIdentity?: string | undefined;
+    lastWaitsError?: string | undefined;
+    automaticWakes?: number | undefined;
+    waitDeliveryFailures?: number | undefined;
     runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
-    agentProfile?: string | undefined;
-    systemPrompt?: string | undefined;
-    generateFollowups?: boolean | undefined;
-    autonomous?: boolean | undefined;
     notify?: boolean | undefined;
     webhook?: {
         lastDeliveredAt?: string | undefined;
         lastError?: string | undefined;
-    } | undefined;
-    automation?: {
-        automationId: string;
-        automationRevision: number;
-        receiptId: string;
-        event: string;
-        githubUrl: string;
-    } | undefined;
-    automationTrigger?: {
-        automationId: string;
-        automationRevision: number;
-        receiptId: string;
-        trigger: "catch-up" | "manual" | "schedule";
-        occurrenceAt: string;
+        lastErrorWebhookId?: string | undefined;
     } | undefined;
     destroyRetry?: {
         attempts: number;
         nextAt: string;
         needsAttention?: true | undefined;
     } | undefined;
-    status: "cancelled" | "done" | "failed" | "queued" | "review" | "running" | "waiting";
     stopping?: boolean | undefined;
-    activity?: "monitoring" | undefined;
-    hasPendingHumanAsk?: boolean | undefined;
-    monitoringWakeAt?: string | undefined;
-    monitoringWakeCapReached?: boolean | undefined;
+    hasPendingPermission?: boolean | undefined;
     autoResumeAt?: string | undefined;
     autoResumeAttempts?: number | undefined;
-    createdAt: string;
-    startedAt?: string | undefined;
-    finishedAt?: string | undefined;
-    tokensUsed: number;
-    inputTokens?: number | undefined;
-    outputTokens?: number | undefined;
-    costUsd?: number | undefined;
-    pullRequestUrl?: string | undefined;
-    referencedPullRequestUrl?: string | undefined;
-    prNumber?: number | undefined;
-    issueNumber?: number | undefined;
-    referencedIssueNumberSeeded?: boolean | undefined;
-    titleOrigin?: "auto" | "marker" | "user" | undefined;
-    markerRefs?: {
-        pr?: number | undefined;
-        issue?: number | undefined;
-    } | undefined;
-    referencedPrCandidates?: string[] | undefined;
-    referencedIssueUrl?: string | undefined;
-    referencedIssueCandidates?: string[] | undefined;
-    worktree?: false | undefined;
-    worktreePath?: string | undefined;
-    branch?: string | undefined;
-    baseBranch?: string | undefined;
-    worktreeReclaimedAt?: string | undefined;
+    pullRequests?: {
+        number: number;
+        url?: string | undefined;
+        source: "created" | "declared";
+    }[] | undefined;
     worktreeSetup?: {
         status: "done" | "failed" | "running";
         startedAt: string;
@@ -1216,19 +2032,31 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
         durationMs?: number | undefined;
         error?: string | undefined;
     } | undefined;
-    groupId?: string | undefined;
-    variant?: string | undefined;
-    clientRequestId?: string | undefined;
-    clientRequestHash?: string | undefined;
-    peakRssBytes?: number | undefined;
-    peakProcCount?: number | undefined;
     archived: boolean;
-    archivedAt?: string | undefined;
-    pinned?: boolean | undefined;
-    pinnedAt?: string | undefined;
-    seenAt?: string | undefined;
-    currentStepId?: string | undefined;
-    error?: string | undefined;
+    workflowDef?: {
+        name: string;
+        description?: string | undefined;
+        steps: {
+            id: string;
+            name?: string | undefined;
+            prompt?: string | undefined;
+            skill?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            timeoutMs?: number | undefined;
+            runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+            agentProfile?: string | undefined;
+            allowedTools?: string[] | undefined;
+            bashAllowlist?: string[] | undefined;
+            command?: string | undefined;
+            onFail?: {
+                retry: string;
+                max: number;
+            } | undefined;
+        }[];
+        source: "built-in" | "file";
+        path?: string | undefined;
+    } | undefined;
     steps: {
         id: string;
         name: string;
@@ -1248,34 +2076,37 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
         finishedAt?: string | undefined;
         error?: string | undefined;
         sessionId?: string | undefined;
-        backend?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+        sessionTransport?: "cursor-acp" | "cursor-print" | undefined;
         profileId?: string | undefined;
         costUsd?: number | undefined;
         synthetic?: "continuation" | undefined;
+        backend?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
     }[];
-    workflowDef?: {
-        name: string;
-        description?: string | undefined;
-        steps: {
-            id: string;
-            name?: string | undefined;
-            prompt?: string | undefined;
-            skill?: string | undefined;
-            model?: string | undefined;
-            effort?: string | undefined;
-            timeoutMs?: number | undefined;
-            runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
-            agentProfile?: string | undefined;
-            allowedTools?: string[] | undefined;
-            bashAllowlist?: string[] | undefined;
-            command?: string | undefined;
-            onFail?: {
-                retry: string;
-                max: number;
+    automation?: {
+        automationId: string;
+        receiptId: string;
+        event: string;
+        automationRevision: number;
+        githubUrl: string;
+    } | undefined;
+    automationTrigger?: {
+        automationId: string;
+        receiptId: string;
+        trigger: "catch-up" | "manual" | "schedule";
+        occurrenceAt: string;
+        automationRevision: number;
+    } | undefined;
+    handoffRecords?: {
+        autosave: {
+            at: string;
+            note: string;
+            periodic?: {
+                branch: string | null;
+                count: number;
+                first: string | null;
+                latest: string | null;
             } | undefined;
         }[];
-        source: "built-in" | "file";
-        path?: string | undefined;
     } | undefined;
 }[]>;
 /** One stored record and what its JSON holds beyond the runtime schema (raw-record.ts), which
@@ -1283,6 +2114,8 @@ export declare function parseRunRecords(raw: unknown): z.ZodSafeParseResult<{
 export interface DecodedRun {
     run: RunRecord;
     extras: RawExtras | undefined;
+    /** The stored JSON still had schema-3 wait fields (`upgradeLegacyWaits`): open rewrites it. */
+    upgraded?: true;
 }
 /** One database row's `data` back into a record and its extras. Undefined when it does not parse:
  *  one unreadable row costs that row only. */
@@ -1294,13 +2127,7 @@ export type StepState = z.infer<typeof stepStateSchema>;
 export type QueuedMessage = z.infer<typeof queuedMessageSchema>;
 export type RunRecord = z.infer<typeof runRecordSchema>;
 /** One persisted event line; `type` mirrors AgentEvent plus engine lifecycle. */
-export interface RunEvent {
-    seq: number;
-    ts: string;
-    stepId?: string;
-    type: string;
-    [key: string]: unknown;
-}
+export type RunEvent = import('../contract/index.js').RunEvent;
 /** How many archived root runs the run lists carry per project (#864): `GET /run-summaries?archived=recent`
  *  and `GET /workspace/runs-index`. Unarchived runs are never cut; older archived runs page in
  *  through `GET /run-summaries/archived` and the workspace search. */
@@ -1328,16 +2155,11 @@ export declare function reconcileLoadedRun(run: RunRecord, opts?: {
     keepLive?: boolean;
 }): RunRecord;
 /**
- * Settle a live run whose owning process died, when a control adopts it (#779, plan step 3), so
- * that adopting never starts agent work: only Continue may, with the user's own input. A run that
- * never started is cancelled before it began, which Continue restarts as it would after a Stop (the
- * same "untouched" test as `isUntouchedCancelledRun`); any other live run is interrupted, exactly as
- * an open that does not recover settles it, and Continue resumes its last session. With `stop`
- * (the control is Stop, and this is its run) a live run is cancelled instead, as an accepted Stop
- * always reads. Mutates `run`.
+ * Settle an adopted dead owner’s live run without starting work. Untouched runs cancel; started
+ * runs become interrupted. Stop explicitly cancels its target. Mutates run.
  */
 export declare function settleOrphanedRun(run: RunRecord, opts?: {
-    stop?: boolean;
+    stop?: boolean | undefined;
 }): RunRecord;
 /**
  * Drop this run's referenced PR/issue if the project's handle proves it foreign and the prompt
@@ -1395,8 +2217,9 @@ export declare class RunWriteRefusedError extends Error {
 }
 /** Newest first, runs created in the same millisecond in insertion order: the order `runs.db`
  *  lists in, and the order every list had while it was a stable sort of the in-memory map. */
-/** Why a `run` event fired, when a delegation checkpoint caused it (in-process only). */
-export type CommitSource = 'delegation-checkpoint' | 'delegation-destroy-progress';
+/** Why a `run` event fired, when a delegation checkpoint caused it or nothing durable changed
+ *  (`republish`) (in-process only). */
+export type CommitSource = 'delegation-checkpoint' | 'delegation-destroy-progress' | 'live-release';
 /**
  * A stored summary, or undefined when the row holds none (a row seeded without one, or text that
  * is not a summary): the caller then projects the record instead. The column is written only by
@@ -1406,43 +2229,10 @@ export type CommitSource = 'delegation-checkpoint' | 'delegation-destroy-progres
  * projects' databases, still validates in full.
  */
 export declare function parseStoredSummary(text: string): RunSummary | undefined;
-/** The bulk-archive sweep's one predicate (#780): finished, not archived, not scheduled (a
- *  `failed` run waiting out a usage limit), not an owned worker (those leave with their parent),
- *  then filtered by pin state. Mirrored clause for clause by `isSweepable` in the cockpit's
- *  `lib/tasks-table.ts`. */
-export declare function isSweepable(run: Pick<RunRecord, 'archived' | 'status' | 'autoResumeAt' | 'pinned'> & {
-    delegation?: {
-        role: string;
-    };
-}, scope?: ArchiveFinishedScope): boolean;
 /**
- * File-backed run store: one row per run in `runs.db` (#779, `./run-database.ts`) plus one
- * append-only NDJSON event file per run. Also the in-process event bus the SSE endpoints
- * subscribe to: emits `('run', RunRecord)` and `('event', { runId, event: RunEvent })`.
- *
- * Only the held set lives in memory (#779, Amendment 2): live runs, the runs a RunManager pins,
- * their delegation families, and runs whose latest write has not settled yet (see `isHeld`).
- * `getRun` answers a held run with the held object, so `commitIndex` still installs into the
- * record a caller holds; any other run is read from `runs.db` as a fresh copy every time (frozen
- * under vitest, so an in-place write throws instead of being lost). Writes to a finished run go
- * through the methods here, which load it, change it and persist the row like any other.
- *
- * Two write paths, both through `writeIndex`:
- * - optimistic: a method changes the held record, marks it dirty and schedules the debounced
- *   save, which writes the dirty rows and deletions only;
- * - durable (`commitIndex`): one transaction with the changed rows AND everything a debounced
- *   save still owes. Only once it commits do the records change in memory, and only then do
- *   subscribers hear about it.
- *
- * Several processes may open one project (`serve` and a headless `cez run`), so a store writes
- * only the delegation families it claims in `run_claims` (#779, plan step 3; `run-claims.ts`).
- * Everything it holds is claimed: open claims the live rows nobody alive owns and leaves the rest
- * alone, and a write to a run not in memory claims its family first, or refuses it while another
- * live process owns it. Claims are released once a family leaves memory, and all of them on
- * `close()`; a crashed owner's are taken over only once it is proven dead. Every write is fenced
- * in its transaction: if a row is not as this store last saw it, or its claim is gone, nothing is
- * written, the evidence goes to `run_conflicts` and this store stops writing that row
- * (`handleConflicts`).
+ * Run rows in runs.db plus append-only NDJSON events and an in-process event bus. Hold live,
+ * pinned, related and unsettled records only. Optimistic writes debounce; durable commits
+ * publish after persistence. Family claims fence every write.
  */
 export declare class RunStore extends EventEmitter {
     private readonly dataDir;
@@ -1498,6 +2288,18 @@ export declare class RunStore extends EventEmitter {
     private readonly compressor;
     /** Transcript facts the delegation paths ask about, so they never re-read a transcript (#880). */
     private readonly facts;
+    private readonly liveItems;
+    /** Capture both sources on the same synchronous sequence boundary before history IO. */
+    liveReadSnapshot(runId: string): {
+        events: {
+            [x: string]: unknown;
+            seq: number;
+            ts: string;
+            stepId?: string | undefined;
+            type: string;
+        }[];
+        throughSeq: number;
+    };
     private constructor();
     /**
      * Open the project's run store. See `reconcileLoadedRun` for what `keepLive` (#367) decides
@@ -1517,8 +2319,9 @@ export declare class RunStore extends EventEmitter {
      * one busy timeout.
      */
     static open(dataDir: string, opts?: {
-        keepLive?: boolean;
+        keepLive?: boolean | undefined;
         retryBusy?: boolean;
+        maintenance?: boolean;
     }): RunStore;
     private static openOnce;
     /**
@@ -1546,7 +2349,9 @@ export declare class RunStore extends EventEmitter {
     private loadHeldRows;
     /** Normalize a record just read from `row` (see `reconcileLoadedRun`) and hold it. Marks the row
      *  dirty only when normalization changed it, so the next save persists exactly the runs open()
-     *  rewrote. The caller has claimed the row's family. */
+     *  rewrote. A row read up from schema-3 wait fields counts as changed: its rewrite drops them
+     *  and recomputes its summary and live column (`upgradeLegacyWaits`). The caller has claimed
+     *  the row's family. */
     private adoptLoadedRun;
     /**
      * Hold one delegation family: its root and the root's direct workers, read through the
@@ -1584,12 +2389,9 @@ export declare class RunStore extends EventEmitter {
     /** Why a control on this run must be refused here, or undefined when this store may change it. */
     writeRefusal(id: string): string | undefined;
     /**
-     * Take over the delegation family of an `orphaned` run for a control: claim it from its dead
-     * owner (or from nobody), then load it and settle its live rows (`settleOrphanedRun`) — never
-     * keep them for recovery to resume, since only Continue may start agent work. With `stop` the
-     * control is Stop: `id` itself is settled as cancelled rather than interrupted. Returns the
-     * family's root id, or undefined when a live owner holds it after all or it is gone. The caller
-     * runs recovery for that family next (`RunManager.adoptOrphanedRun`), which then repairs it.
+     * Claim an orphaned family and settle its live rows before a control acts. Stop cancels its
+     * target. Return the root id, or undefined for a live owner or missing run; adoption never
+     * resumes work.
      */
     adoptFamily(id: string, opts?: {
         stop?: boolean;
@@ -1654,23 +2456,15 @@ export declare class RunStore extends EventEmitter {
      * loaded. Pins are per holder, so releasing one never releases another. Returns the held record.
      */
     pin(id: string, holder: RunPinHolder): RunRecord | undefined;
+    /** Publish a run's current record again without a write: something read beside the record
+     *  changed, such as the run leaving the manager's live registries, which a detail's finish
+     *  verdict reads (hearsay-tools/cezarion#1301). */
+    republish(id: string): void;
     /** Release `holder`'s pin. The run leaves memory at the next sweep once nothing else holds it. */
     unpin(id: string, holder: RunPinHolder): void;
     /**
-     * Tell the store which repository this project IS (#945), so the referenced tier stops adopting
-     * another repo's PR/issue as the task's subject. See `isRepoScopedRef` for the rule.
-     *
-     * A setter rather than an `open()` option because `open()` is synchronous and the handle costs a
-     * `gh` spawn: callers arm this in the background so boot never waits on the network. `null` is a
-     * first-class answer meaning "cannot be known" (no `gh`, no remote, a non-git root) and leaves
-     * the store in exactly its pre-#945 behavior.
-     *
-     * Arming also HEALS records already poisoned by the un-scoped rule, on the `reconcileLoadedRun`
-     * precedent: the evidence is all still on the record (`referenced*Candidates`), only the
-     * conclusion drawn from it was wrong, so re-deciding beats asking for a migration. It rewrites
-     * values, never the format, and is one-directional by construction — see `rescopeRun`. Held
-     * runs are re-checked in memory; of the rest, only rows whose stored summary references another
-     * repository are decoded, and the healed ones are written, so their summaries heal too.
+     * Set discovered repository identity without blocking boot. Recompute conclusions from retained
+     * evidence, including cold records; null retains unknown-handle behavior.
      */
     setRepoHandle(handle: RepoHandle | null): void;
     /** Whether the stored summary still names a reference the scoped record no longer has. */
@@ -1678,7 +2472,7 @@ export declare class RunStore extends EventEmitter {
     /**
      * The live set, newest first: runs whose record is live (`isLiveRecord`) or that a RunManager
      * pins. Finished runs are not here — read one by id (`getRun`), by an indexed query
-     * (`listWorkersOf`, `findRunByClientRequestId`, `listGroupRuns`, `listRunsWithWorktree`,
+     * (`listWorkersOf`, `findRunByClientRequestId`, `listRunsWithWorktree`,
      * `listBranchOwners`), or as list rows (`listRunSummaries`).
      */
     listRuns(): RunRecord[];
@@ -1708,7 +2502,7 @@ export declare class RunStore extends EventEmitter {
      * which decodes nothing; reading it is what finds out (`isUnreadable`).
      */
     listRunSummaries(options?: {
-        archivedWindow?: number;
+        archivedWindow?: number | undefined;
         roots?: boolean;
     }): {
         runs: RunSummary[];
@@ -1718,7 +2512,9 @@ export declare class RunStore extends EventEmitter {
      * One page of archived ROOT runs, newest first (#864): `GET /run-summaries/archived`, the
      * archived runs past the window. Held runs list by their record, as in `listRunSummaries`.
      * `before` is the previous page's `nextCursor`; with `q`, only runs `matchesRunQuery` keeps, and
-     * `total` counts those. A cursor this store did not write answers `{ error }`.
+     * `total` counts those. `automationNames` lets `q` match a task by its automation's name, as the
+     * list's origin line shows it (hearsay-tools/cezarion#1616). A cursor this store did not write
+     * answers `{ error }`.
      *
      * Ranking reads every archived root's key (id, created_at, seq: no record, no summary), so the
      * page and `total` agree with the held overlay; only the page's own rows are read in full.
@@ -1727,11 +2523,27 @@ export declare class RunStore extends EventEmitter {
         before?: string;
         limit: number;
         q?: string;
+        automationNames?: AutomationNames;
     }): ArchivedRunsResponse | {
         error: string;
     };
+    /** The archived roots in `runs.db`, each by its key: every one without `q` (no record, no
+     *  summary read), and with `q` the searched rows `matchesRunSearch` keeps, which carry the summary
+     *  the search read. A deleted, held or unreadable run's row is left out; a held run joins in
+     *  `overlayHeldArchived`. */
+    private rankArchivedRows;
+    /** Lay the held archived roots over `ranked`, each by its record: it replaces its stored row
+     *  (already left out of `ranked`), and with `q` it must match. A held worker never lists. */
+    private overlayHeldArchived;
+    /** The page of `ordered` after the cursor `after`: its summaries, the cursor of the next page,
+     *  and `total`, the count of all of `ordered`. */
+    private archivedPage;
+    /** The page's summaries: a ranked key's own, else its stored one, read for the rows that have
+     *  none in a single query. A row whose stored summary does not fit the contract is projected from
+     *  its record; a row that cannot be read at all is left out. */
+    private hydrateArchivedPage;
     /**
-     * The ROOT runs, archived or not, that match `query` (`matchesRunQuery`), newest first: at most
+     * The ROOT runs, archived or not, that match `query` (`matchesRunSearch`), newest first: at most
      * `limit`, and whether more matched. The owned half of the workspace search (#864); held runs
      * match by their record.
      */
@@ -1770,6 +2582,12 @@ export declare class RunStore extends EventEmitter {
     /** The id of every run whose delegation is quarantined (`invalid`), held or stored: its stored
      *  summary says so, so nothing is decoded (scratch cleanup). */
     listQuarantinedRunIds(): string[];
+    /** All retained tasks this automation started, including variants, finished and archived runs.
+     * Logs and receipts may compact independently. Read only matching keys in SQLite and overlay
+     * held records so a debounced provenance update or deletion is reflected immediately. */
+    countAutomationRuns(automationId: string): number;
+    /** First non-archived task referencing a project issue, including secondary references. */
+    findNonArchivedRunByIssue(repo: string, number: number): string | undefined;
     /**
      * The runs automation receipts launched, by receipt id (`automation.receiptId` or
      * `automationTrigger.receiptId`). Memory answers first; a receipt it does not know costs one
@@ -1783,8 +2601,6 @@ export declare class RunStore extends EventEmitter {
     listConversationRootIds(): string[];
     /** The id of every run, held or stored, without decoding any (orphan-worktree sweeps). */
     listRunIds(): string[];
-    /** The members of one parallel-variant group (spec 010), in no particular order. */
-    listGroupRuns(groupId: string): RunRecord[];
     /** Runs with a materialized worktree directory (`worktreePath`, not reclaimed), most recently
      *  finished first, then newest first: worktree retention and the worktrees panel. */
     listRunsWithWorktree(): RunRecord[];
@@ -1803,25 +2619,30 @@ export declare class RunStore extends EventEmitter {
     findRunByClientRequestId(clientRequestId: string): RunRecord | undefined;
     createRun(input: {
         title: string;
-        systemPrompt?: string;
+        systemPrompt?: string | undefined;
         workflowDef?: z.infer<typeof workflowDefSchema>;
         workflow: string;
         task: string;
-        model?: string;
+        model?: string | undefined;
         /** Reasoning-effort pin (#45). Absent = harness default. */
-        effort?: string;
-        runner?: RunnerId;
+        effort?: string | undefined;
+        runner?: RunnerId | undefined;
         /** Composer's per-task agent account (spec 2026-07-29-agent-profiles). */
-        agentProfile?: string;
-        generateFollowups?: boolean;
-        autonomous?: boolean;
+        agentProfile?: string | undefined;
+        autonomous?: boolean | undefined;
+        archiveWhenDone?: boolean | undefined;
+        autoMergePr?: boolean | undefined;
         /** Task webhook opt-in (#589), set at creation so the first transition is already covered. */
-        notify?: boolean;
-        worktree?: false;
+        notify?: boolean | undefined;
+        worktree?: false | undefined;
         groupId?: string;
         variant?: string;
-        clientRequestId?: string;
-        clientRequestHash?: string;
+        clientRequestId?: string | undefined;
+        clientRequestHash?: string | undefined;
+        /** Automation provenance, committed with the row that creates the run (hearsay-tools/cezarion#1465):
+         *  a crash before a later write must still let reconciliation find the receipt's task. */
+        automation?: RunRecord['automation'];
+        automationTrigger?: RunRecord['automationTrigger'];
         steps: Array<Pick<StepState, 'id' | 'name' | 'kind'>>;
     }): RunRecord;
     /** Build without publishing: owned creation must commit its receipt and run together. */
@@ -1831,35 +2652,59 @@ export declare class RunStore extends EventEmitter {
         recipientRunId: string;
         input: AgentInput;
     }): void;
-    /** Observable atomic input checkpoint: a failed write publishes nothing. */
-    /** Accepted input the harness will never read returns to the queue (#505): only its
-     * delivery and consumption receipts are cleared; order and identity are kept. */
-    requeueUnconsumedAgentInputs(id: string, ids: readonly string[]): void;
-    /** Model consumption observed by the current session (#505). Never un-sets deliveredAt. */
-    commitAgentInputsConsumed(id: string, ids: readonly string[], at: string): void;
-    /** Delivered, but the harness never confirmed reading it (#505): stop awaiting a read. */
-    commitAgentInputsUnconfirmed(id: string, ids: readonly string[]): void;
     /** Crash recovery (#505): input a harness accepted but was never seen reading goes
      * back to the queue. Returns the requeued IDs. */
     requeueAwaitingReadInputs(id: string): string[];
-    commitAgentInputs(id: string, inputs: readonly AgentInput[], openingContinuationInputId?: string): void;
+    /** Delivered, but the harness never confirmed reading it (#505): stop awaiting a read. */
+    commitAgentInputsUnconfirmed(id: string, ids: readonly string[]): void;
+    /** Observable atomic input checkpoint for the queue itself: enqueue, retire, reorder. Delivery
+     *  and reads are outcomes (`commitOutcome`). */
+    commitAgentInputs(id: string, inputs: readonly AgentInput[]): void;
     /** Reserve only unread conversation inputs in one durable index replacement. */
     claimInboxInputs(runId: string, ids: readonly string[], claim: InboxClaim): void;
     /** A receipt owns every matching input or none; exact ACK retries preserve the first timestamp. */
     ackInboxInputs(runId: string, receiptId: string, generation: string, at: string): 'acknowledged' | 'already-acknowledged';
     releaseInboxInputs(runId: string, receiptId: string, generation: string): 'released';
     clearExpiredInboxClaims(runId: string, now: string): void;
-    /** CI intent and its wake entry share one atomic index replacement. */
+    /**
+     * A wait and its wake input share one atomic index replacement (spec 2026-10-17-unified-waits).
+     * Upserts `wait` by id into `waits` and clears `lastWaitsError`; `input` is appended once (an
+     * input whose id is already queued stays as it is). Only an open or resolved wait is committed
+     * here: settling is an outcome (`commitOutcome`). A new open wait
+     * past `WAIT_LIMIT` open ones is refused, so the list stays bounded whatever the caller checked.
+     */
+    commitWait(id: string, wait: Wait, input?: AgentInput): void;
+    /** A park that gives up its slot (hearsay-tools/cezarion#1235): the run and its step read
+     *  `waiting`, committed at once instead of on the debounced save, so a refused write throws with
+     *  nothing changed and the caller keeps the slot. */
+    commitParked(id: string, stepId?: string): void;
+    /** A usage-limit appointment withdrawn, committed at once instead of on the debounced save
+     *  (hearsay-tools/cezarion#1236): a crash right after the withdrawal must not find it on disk,
+     *  or recovery re-arms work the user cancelled. A run held for its resume settles `failed`. */
+    commitAutoResumeWithdrawal(id: string): void;
+    /** Legacy CI checkpoint over `commitWait`, kept until its callers move (unified waits, Task 4). */
     commitCiWait(id: string, wait: CiWait, input?: AgentInput): void;
-    /** Retire the wait and precisely its pending wake, optionally accepting human input. */
-    commitCiWaitWithdrawal(id: string, acceptedHumanMessage?: QueuedMessage): void;
-    /** Provider acceptance and receipt retirement have one delivery checkpoint. */
-    commitCiWaitDelivery(id: string, inputId: string): void;
-    /** Retain the settled receipt and retire exactly one wait together with any human message that superseded it. */
-    commitWorkerWaitWithdrawal(id: string, waitId: string, acceptedHumanMessage?: QueuedMessage): void;
-    /** Successful deferred human delivery consumes only its persisted queue ID.
-     * A crash before this checkpoint may replay that same message on recovery. */
-    commitQueuedMessageDelivery(id: string, messageId: string): void;
+    /** A human message beside a run's waits (hearsay-tools/cezarion#1235): accepted durably, and
+     *  every wait stays. A lifecycle opening becomes
+     *  the human's and keeps its wake text, so the message opens the continuation (and answers a
+     *  pending question) and the owed results still reach the agent. */
+    commitHumanMessageBesideWaits(id: string, acceptedHumanMessage: QueuedMessage): void;
+    /**
+     * The one write of a run outcome (hearsay-tools/cezarion#1805): an input or wait delivered, a wake
+     * charged, a wait settled, a question answered, staged by `applyOutcomes` with what it depends on
+     * (`deps`) and committed in one transaction, with every pending row. A crash keeps all of it or
+     * none. Nothing changes: nothing is written. Needs no live session: it reads the stored record.
+     *
+     * A refused write throws with nothing changed. `bestEffort` is for a cleanup path, which must
+     * never stop on it: it warns and applies the change in memory for the debounced save to retry.
+     * A conversation request outcome is the other sanctioned write: `commitConversation`.
+     */
+    commitOutcome(id: string, outcomes: RunOutcome | readonly RunOutcome[], deps?: OutcomeDependencies, opts?: {
+        bestEffort?: boolean;
+    }): {
+        committed: boolean;
+        answered: string[];
+    };
     /** An acknowledged inactive-root Finish must survive the async diff and restart. */
     commitRootFinishIntent(id: string): void;
     /** Cancellation supersedes pending Finish in one durable checkpoint. Also
@@ -1901,16 +2746,25 @@ export declare class RunStore extends EventEmitter {
      */
     createOwnedRun(input: Parameters<RunStore['createRun']>[0], parentId: string, requestId: string, worker: DelegationState, requestHash: string, executionIdentity?: WorkerExecutionIdentity): RunRecord;
     /**
-     * The durable write: `staged` holds the records this operation replaces (`null` deletes one),
-     * in the order subscribers hear about them. The transaction is the durability boundary;
-     * flush() is deliberately best-effort.
-     *
-     * One transaction carries the staged rows and every row a debounced save still owes, so the
-     * database never holds a commit without the optimistic writes made before it. If it fails,
-     * nothing changed anywhere: the held records, the database, the pending dirty rows and the
-     * subscribers all see the store as it was.
+     * Durably replace or delete staged rows together with pending dirty rows. Persist before
+     * changing held objects or notifying subscribers. On failure retain all pending state; flush()
+     * remains best-effort.
      */
     private commitIndex;
+    /** Completion and its intent/archive share the same committed rows, including root Finish. */
+    private prepareCompletionActions;
+    private completionArchiveBlocker;
+    /** One archive write for manual actions, merge observations, completion, and sweeps.
+     * Archiving files history away; it never stops a process or removes a worktree. */
+    private stageArchive;
+    /** A bounded persisted queue also covers projects without a live RunManager. */
+    listCompletionCandidates(afterSeq?: number, limit?: number): Array<{
+        id: string;
+        seq: number;
+    }>;
+    canCompleteAction(id: string, token: string): boolean;
+    claimCompletionAction(id: string, token: string): boolean;
+    completeAction(id: string, token: string, phase: 'blocked' | 'complete', message?: string): boolean;
     /**
      * Refuse (throwing, with nothing changed) a commit that stages a quarantined run, or a run whose
      * family this store does not claim and cannot take: another process owns it, or a dead process
@@ -1951,6 +2805,21 @@ export declare class RunStore extends EventEmitter {
     /** Append a step to an existing run (used by "Continue" — spec 003). */
     addStep(runId: string, step: Pick<StepState, 'id' | 'name' | 'kind' | 'synthetic'>): void;
     updateStep(runId: string, stepId: string, patch: Partial<Omit<StepState, 'id'>>): void;
+    listArchiveOnMergeCandidates(afterSeq?: number, limit?: number): Array<{
+        id: string;
+        seq: number;
+    }>;
+    /** Use unnormalized persisted evidence: cold reads must not turn interrupted work into safety. */
+    private archiveFamily;
+    /** Blockers are feedback, never archive authority or cleanup permission. */
+    setArchiveBlocker(id: string, blocker: RunRecord['archiveBlocker']): void;
+    archiveMergeBlocker(snapshot: ArchiveOnMergeSnapshot, missing: ArchivePullRequestIdentity, repoBase?: string): void;
+    hasArchiveOnMergeAssociations(id: string): boolean;
+    prepareArchiveOnMerge(id: string): Promise<void>;
+    archiveOnMergeSnapshot(id: string, repoBase?: string, isActive?: (id: string) => boolean): ArchiveOnMergeSnapshot | undefined;
+    private archiveSnapshot;
+    /** No await between final revalidation and the fenced, all-or-nothing cascade. */
+    archiveAfterMerge(snapshot: ArchiveOnMergeSnapshot, observations: readonly MergedPullRequest[], repoBase?: string, isActive?: (id: string) => boolean): boolean;
     setArchived(id: string, archived: boolean): RunRecord | undefined;
     /** Parent + owned workers; returns how many records flipped `archived`. */
     private applyArchivedCascade;
@@ -1980,7 +2849,7 @@ export declare class RunStore extends EventEmitter {
     /** Bulk-archive finished runs (#780). `isSweepable` decides which; `archived` counts every
      *  record that flipped (cascaded workers included), `ids` lists the top-level runs picked and
      *  `pinnedIds` the subset that carried a pin before `clearPin` dropped it. */
-    archiveFinished(scope?: ArchiveFinishedScope): {
+    archiveFinished(scope?: ArchiveFinishedScope, automation?: boolean): {
         archived: number;
         ids: string[];
         pinnedIds: string[];
@@ -2004,34 +2873,16 @@ export declare class RunStore extends EventEmitter {
      *  the marker. WHETHER the action means anything for a given run is UI policy, and lives
      *  in the cockpit's `runActionFlags` — the same split the rest of the store keeps. */
     setUnread(id: string): RunRecord | undefined;
-    /** Bulk mark-read: stamp every currently-unread finished run; returns the count.
-     *  "Unread" here is the same rule the cockpit paints (`isUnread` in read-state.ts),
-     *  clause for clause:
-     *   - a `done` or `failed` run that finished and has not been seen since;
-     *   - cancelled runs are never unread — you stopped them yourself;
-     *   - archived ones never are either, since archiving is a stronger "done with this"
-     *     than reading;
-     *   - and a `failed` run with a pending `autoResumeAt` is not a done item AT ALL
-     *     (`isScheduledResume`, spec 2026-08-03-auto-resume-after-usage-limit): it has an
-     *     appointment to pick the work back up, so there is no outcome to have missed.
-     *
-     *  Keeping the two rules identical is what makes the returned count the number the
-     *  cockpit's unread badge was showing. The `autoResumeAt` clause is the one that drifted
-     *  (#803): `isUnread` gained it with auto-resume and this sweep did not, so a task waiting
-     *  out a usage limit was uncounted by the badge but stamped read by the sweep — and this
-     *  comment asserted an invariant the code no longer held.
-     *
-     *  This rule lives in two languages of the same repo, which is why it has now drifted
-     *  once. The cockpit cannot import it (`packages/web` does not depend on the service, and
-     *  should not), so a single definition would have to move to `packages/contract` — the one
-     *  package both sides already import. Worth doing; deliberately not done here, because
-     *  widening the contract package's remit from "shapes" to "behavior" is a design change
-     *  that deserves its own review rather than riding along in a bug fix. Until then: EDIT
-     *  BOTH, and the case-table tests on either side are what catch you if you don't. */
-    markAllRead(): number;
+    /**
+     * Stamp unread finished runs in bulk and return the count. Keep the rule aligned with cockpit
+     * isUnread: done/failed, finished since seen, not archived; cancelled and usage-limit waiting
+     * runs are excluded. `automation` narrows it to one origin, as in `archiveFinished`
+     * (hearsay-tools/cezarion#1616); absent stamps both.
+     */
+    markAllRead(automation?: boolean): number;
     appendEvent(runId: string, event: {
         type: string;
-        stepId?: string;
+        stepId?: string | undefined;
         [key: string]: unknown;
     }): RunEvent;
     /**
@@ -2052,7 +2903,7 @@ export declare class RunStore extends EventEmitter {
     /**
      * Apply agent-declared reference markers (spec 2026-07-18-task-ref-markers).
      * Marker values are authoritative for the display tier: they overwrite the
-     * regex/namer numbers, and a declared PR re-resolves the referenced URL
+     * regex/namer numbers unless the prompt identifies the originating issue, and a declared PR re-resolves the referenced URL
      * against the candidate working set — including down to `undefined` when no
      * candidate matches (a wrong chip is worse than no chip). The created tier
      * (`pullRequestUrl`) is deliberately untouched.
@@ -2062,16 +2913,21 @@ export declare class RunStore extends EventEmitter {
      * re-declare after it opens a PR, and taking that literally cost the task the PR it was about.
      */
     applyMarkerRefs(runId: string, refs: {
-        pr?: number;
-        issue?: number;
+        pr?: number | undefined;
+        prs?: readonly number[] | undefined;
+        issue?: number | undefined;
     }): RunRecord | undefined;
+    /** Authoritative creation keeps the first scalar for publishing, plus every created identity. */
+    recordCreatedPr(runId: string, url: string): RunRecord | undefined;
+    private accumulatePullRequests;
     /**
      * Fan an event out to live subscribers WITHOUT writing it to the NDJSON
      * file — the channel for coalesced `item.delta` flushes (protocol-v2
      * performance guardrail: raw deltas never hit disk; replay = the persisted
      * snapshots). Stamped with `seq`/`ts` like persisted lines so the live
-     * wire keeps one ordering axis; the seq simply never appears in a replay
-     * (gaps are fine — dedup compares with `>`).
+     * wire keeps one ordering axis. Finite polling coalesces active item content
+     * into bounded in-memory snapshots on that clock; disk replay still has gaps
+     * (dedup compares with `>`).
      */
     emitEphemeral(runId: string, event: {
         type: string;
@@ -2096,18 +2952,23 @@ export declare class RunStore extends EventEmitter {
     /** The run's indexed transcript facts (#880): a read-only view, never a transcript read once
      *  the run's index is loaded. An unreadable transcript answers as empty, as readEvents does. */
     transcriptFacts(runId: string): Readonly<TranscriptFacts>;
+    /** The run's transcript facts when they are known: undefined when the transcript exists but its
+     *  facts are not current or cannot be read, so a caller can tell "no ask" from "no evidence". */
+    knownTranscriptFacts(runId: string): Readonly<TranscriptFacts> | undefined;
     hasProjection(runId: string, projectionId: string): boolean;
     private factsWarming;
-    /** After open, build the indexes the delegation reconcile will ask for first, off the request
-     *  path: every member of every family with a conversation (#880). */
+    /** Indexed family enumeration, including members not yet flushed to SQLite. */
+    listFamilyRunIds(rootId: string): string[];
+    private recoveryFactIds;
+    /** Readiness owns no run snapshot across an await: refresh only the currently held owner. */
+    prepareTranscriptFacts(runIds: Iterable<string>): Promise<void>;
+    prepareRecoveryFacts(familyRootId?: string): Promise<void>;
+    /** Register IDs only here; the index yields between cache reads and off-loop rebuilds. */
     private warmTranscriptFacts;
     /** Resolves when the open-time warm-up is done (tests). */
     factsWarmIdle(): Promise<void>;
     /** `readEvents` off the event loop (async read and async brotli), for collection paths. */
     readEventsAsync(runId: string): Promise<RunEvent[]>;
-    /** The owned store's `refreshHumanAskSummary`, from the index, on the same rules: no history
-     *  (legacy runs) keeps the summary, an unreadable one requests attention. True when it changed. */
-    private syncHumanAskSummary;
     readEvents(runId: string): RunEvent[];
     /** Private process-generation evidence; never part of run JSON or SSE. */
     private identityPath;
@@ -2122,7 +2983,7 @@ export declare class RunStore extends EventEmitter {
     /** `workerResourcesSafe` with the refusal's live PIDs (empty when no PID explains it). */
     workerResourceHolders(id: string, generation: string, resourceId: string, opts?: {
         admittingQueued?: boolean;
-        cwds?: CwdSource;
+        cwds?: CwdSource | undefined;
     }): 'safe' | number[];
     /** Upgrade a legacy completed checkpoint while terminal task ownership is still known.
      * No holder scan here: settlement and scheduling must never wait on cleanup proof. */
@@ -2206,23 +3067,9 @@ export declare class RunStore extends EventEmitter {
      *  generations it took them, and each row at the revision it last saw (none for a new row). */
     private fence;
     /**
-     * A fenced write found rows that changed under this store (#779, plan step 3); the write itself
-     * has already failed with nothing changed, and its caller sees that error.
-     *
-     * A conflict is UNEXPECTED when this store owned the row's family when it last read or wrote it:
-     * a held or pending row, or one read inside a family it claimed. Another writer then broke the
-     * claim. For each such row the original (what this store last saw), local (what it meant to
-     * write, or that it meant to delete it) and current versions go to `run_conflicts` first. Only
-     * once that evidence is stored does the row leave the pending set, so no retry rewrites it; this
-     * store then refuses to write it again, and its held copy is replaced by the current row (or
-     * dropped when deleted) and announced. That refusal lasts as long as this store: the explicit
-     * recovery is a restart, which reads the row as it now stands, and the evidence row stays for a
-     * person to compare. Other pending rows stay pending and the next save writes them.
-     *
-     * If the evidence cannot be stored, nothing changes: the rows stay pending, and the next write
-     * meets the same conflict and tries again. A row read before its family was claimed may simply
-     * have been finished by its previous owner in between: a stale read, not a conflict, so only the
-     * write fails.
+     * Handle a fenced-write conflict. Save unexpected conflict evidence before clearing pending
+     * state or quarantining the row. If evidence persistence fails, retain pending writes. Other
+     * rows remain writable; stale unclaimed reads only fail their write.
      */
     private handleConflicts;
     /** Write what is pending, then (unless closing) let every run whose write settled leave memory. */
@@ -2235,3 +3082,9 @@ export declare class RunStore extends EventEmitter {
      */
     close(): void;
 }
+export interface ArchiveOnMergeSnapshot {
+    rootId: string;
+    fingerprint: string;
+    pullRequests: ArchivePullRequestIdentity[];
+    token: string;
+}