@hearsay-tools/squawk 0.0.0-stage → 0.17.0-dev.5685

package/dist/runs/store.d.ts

@@ -0,0 +1,3974 @@
+import { type ReportsIndex } from '../artifacts/reports-index.ts';
+import { type PeerTaskPageOptions } from './run-summary-page.ts';
+export { parseStoredSummary } from './run-summary-page.ts';
+import { EventEmitter } from 'node:events';
+import { type WorkerExecution } from './worker-execution.ts';
+import { z } from 'zod';
+import { queuedMessageSchema } from '../contract/index.js';
+import { type WaitRegistrationReceipt } from '../contract/index.js';
+import type { ArchiveFinishedScope, ArchivedRunsResponse, ArchivePullRequestIdentity, ConversationState, AgentInput, InboxClaim, DelegationState, MergedPullRequest, RunSummary, Wait, WorkerCollectedResult, WorkerDestroyRetry } 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 OutcomeReceipt, type RunOutcome } from './outcome-commit.ts';
+import { type ExitCall, type RunExitId, type RunPatch } from './run-exits.ts';
+import { type ConversationIdentity } from './conversation-identity.ts';
+export { ConversationIdInUseError } from './conversation-identity.ts';
+import { type RunnerId } from '../core/agent-runner.ts';
+import { RunDatabase, type RunDatabaseChanges, type RunDatabaseCommit } from './run-database.ts';
+export { ciWaitEntry, holdsWorkerWait, upgradeLegacyWaits, workerWaitEntry } from './legacy-waits.ts';
+import { type RawExtras } from './raw-record.ts';
+import { RunStoreOpenError } from './store-open-error.ts';
+/** Per-store persistence adapter; the second argument is the normal fenced transaction. */
+export type RunStorePersistence = (changes: RunDatabaseChanges, transaction: RunDatabase['transaction']) => RunDatabaseCommit;
+export type RunStatus = 'queued' | 'running' | 'waiting' | 'review' | 'done' | 'failed' | 'cancelled';
+export type StepStatus = 'pending' | 'running' | 'waiting' | 'review' | 'done' | 'failed' | 'cancelled' | 'skipped';
+declare const stepStateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        agent: "agent";
+        check: "check";
+    }>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        pending: "pending";
+        review: "review";
+        running: "running";
+        skipped: "skipped";
+        waiting: "waiting";
+    }>;
+    iterations: z.ZodNumber;
+    retriesUsed: z.ZodOptional<z.ZodNumber>;
+    tokensUsed: z.ZodNumber;
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    usageInvocationsStarted: z.ZodOptional<z.ZodNumber>;
+    usageInvocationsObserved: z.ZodOptional<z.ZodNumber>;
+    usageTurnsStarted: z.ZodOptional<z.ZodNumber>;
+    usageTurnsRecorded: z.ZodOptional<z.ZodNumber>;
+    usageInvocationEpoch: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    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";
+        codex: "codex";
+        cursor: "cursor";
+        omp: "omp";
+        opencode: "opencode";
+        pi: "pi";
+    }>, z.ZodTransform<"claude" | "codex" | "cursor" | "omp" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "cursor" | "omp" | "opencode" | "pi">>>;
+}, 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. */
+export declare const runRecordSchema: z.ZodObject<{
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
+    allowWorkers: z.ZodOptional<z.ZodBoolean>;
+    allowMessaging: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodString;
+    title: z.ZodString;
+    titleSummary: z.ZodOptional<z.ZodString>;
+    diffStat: z.ZodOptional<z.ZodObject<{
+        adds: z.ZodNumber;
+        dels: z.ZodNumber;
+        files: z.ZodNumber;
+        repointed: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    workflow: z.ZodString;
+    task: z.ZodString;
+    queuedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>>;
+    continuationMessage: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        createdAt: z.ZodString;
+        origin: z.ZodOptional<z.ZodEnum<{
+            human: "human";
+            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>;
+    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>;
+            relationship: z.ZodOptional<z.ZodEnum<{
+                family: "family";
+                peer: "peer";
+            }>>;
+        }, 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>>;
+        purpose: z.ZodOptional<z.ZodEnum<{
+            "completion-refusal": "completion-refusal";
+            "undelivered-question": "undelivered-question";
+        }>>;
+        requestHash: z.ZodOptional<z.ZodString>;
+        deadline: z.ZodOptional<z.ZodISODateTime>;
+    }, 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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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";
+            merge_or_blocked: "merge_or_blocked";
+        }>;
+        wakeOnConflict: z.ZodBoolean;
+        result: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                blocked: "blocked";
+                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>;
+            mergeBlock: z.ZodOptional<z.ZodObject<{
+                reason: z.ZodEnum<{
+                    conflict: "conflict";
+                    no_pending_merge: "no_pending_merge";
+                }>;
+                isInMergeQueue: z.ZodBoolean;
+                autoMergeEnabled: z.ZodBoolean;
+                event: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        auto_merge_disabled: "auto_merge_disabled";
+                        queue_removal: "queue_removal";
+                    }>;
+                    createdAt: z.ZodISODateTime;
+                    reason: z.ZodOptional<z.ZodString>;
+                    reasonCode: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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";
+                deleted: "deleted";
+                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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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<"peer">;
+        deadline: z.ZodISODateTime;
+        timeoutSeconds: z.ZodNumber;
+        peerIds: z.ZodArray<z.ZodUUID>;
+        result: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            reason: z.ZodLiteral<"message">;
+            peerRunId: z.ZodUUID;
+            messageId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"settled">;
+            peerRunId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"timeout">;
+        }, z.core.$strict>], "reason">>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        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<"subagent">;
+        source: z.ZodLiteral<"cezar">;
+        via: z.ZodLiteral<"native-subagents">;
+        deadline: z.ZodISODateTime;
+        children: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                completed: "completed";
+                failed: "failed";
+                running: "running";
+            }>;
+        }, z.core.$strict>>;
+        result: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodEnum<{
+                interrupted: "interrupted";
+                settled: "settled";
+                superseded: "superseded";
+                timeout: "timeout";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>>;
+    waitRegistrations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        operationId: z.ZodUUID;
+        requestHash: z.ZodString;
+        wait: 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-message-wait": "cez-message-wait";
+                "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";
+                "native-subagents": "native-subagents";
+                "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";
+                merge_or_blocked: "merge_or_blocked";
+            }>;
+            wakeOnConflict: z.ZodBoolean;
+            result: z.ZodOptional<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    blocked: "blocked";
+                    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>;
+                mergeBlock: z.ZodOptional<z.ZodObject<{
+                    reason: z.ZodEnum<{
+                        conflict: "conflict";
+                        no_pending_merge: "no_pending_merge";
+                    }>;
+                    isInMergeQueue: z.ZodBoolean;
+                    autoMergeEnabled: z.ZodBoolean;
+                    event: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            auto_merge_disabled: "auto_merge_disabled";
+                            queue_removal: "queue_removal";
+                        }>;
+                        createdAt: z.ZodISODateTime;
+                        reason: z.ZodOptional<z.ZodString>;
+                        reasonCode: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                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-message-wait": "cez-message-wait";
+                "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";
+                "native-subagents": "native-subagents";
+                "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-message-wait": "cez-message-wait";
+                "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";
+                "native-subagents": "native-subagents";
+                "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-message-wait": "cez-message-wait";
+                "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";
+                "native-subagents": "native-subagents";
+                "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";
+                    deleted: "deleted";
+                    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-message-wait": "cez-message-wait";
+                "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";
+                "native-subagents": "native-subagents";
+                "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>, z.ZodObject<{
+            id: z.ZodUUID;
+            source: z.ZodEnum<{
+                agent: "agent";
+                cezar: "cezar";
+            }>;
+            via: z.ZodEnum<{
+                "ask-line": "ask-line";
+                budget: "budget";
+                "cez-message-wait": "cez-message-wait";
+                "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";
+                "native-subagents": "native-subagents";
+                "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<"peer">;
+            deadline: z.ZodISODateTime;
+            timeoutSeconds: z.ZodNumber;
+            peerIds: z.ZodArray<z.ZodUUID>;
+            result: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                reason: z.ZodLiteral<"message">;
+                peerRunId: z.ZodUUID;
+                messageId: z.ZodUUID;
+            }, z.core.$strict>, z.ZodObject<{
+                reason: z.ZodLiteral<"settled">;
+                peerRunId: z.ZodUUID;
+            }, z.core.$strict>, z.ZodObject<{
+                reason: z.ZodLiteral<"timeout">;
+            }, z.core.$strict>], "reason">>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodUUID;
+            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<"subagent">;
+            source: z.ZodLiteral<"cezar">;
+            via: z.ZodLiteral<"native-subagents">;
+            deadline: z.ZodISODateTime;
+            children: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    completed: "completed";
+                    failed: "failed";
+                    running: "running";
+                }>;
+            }, z.core.$strict>>;
+            result: z.ZodOptional<z.ZodObject<{
+                reason: z.ZodEnum<{
+                    interrupted: "interrupted";
+                    settled: "settled";
+                    superseded: "superseded";
+                    timeout: "timeout";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">;
+        deduplicated: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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";
+            merge_or_blocked: "merge_or_blocked";
+        }>;
+        wakeOnConflict: z.ZodBoolean;
+        result: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                blocked: "blocked";
+                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>;
+            mergeBlock: z.ZodOptional<z.ZodObject<{
+                reason: z.ZodEnum<{
+                    conflict: "conflict";
+                    no_pending_merge: "no_pending_merge";
+                }>;
+                isInMergeQueue: z.ZodBoolean;
+                autoMergeEnabled: z.ZodBoolean;
+                event: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        auto_merge_disabled: "auto_merge_disabled";
+                        queue_removal: "queue_removal";
+                    }>;
+                    createdAt: z.ZodISODateTime;
+                    reason: z.ZodOptional<z.ZodString>;
+                    reasonCode: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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";
+                deleted: "deleted";
+                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-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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>, z.ZodObject<{
+        id: z.ZodUUID;
+        source: z.ZodEnum<{
+            agent: "agent";
+            cezar: "cezar";
+        }>;
+        via: z.ZodEnum<{
+            "ask-line": "ask-line";
+            budget: "budget";
+            "cez-message-wait": "cez-message-wait";
+            "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";
+            "native-subagents": "native-subagents";
+            "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<"peer">;
+        deadline: z.ZodISODateTime;
+        timeoutSeconds: z.ZodNumber;
+        peerIds: z.ZodArray<z.ZodUUID>;
+        result: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            reason: z.ZodLiteral<"message">;
+            peerRunId: z.ZodUUID;
+            messageId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"settled">;
+            peerRunId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"timeout">;
+        }, z.core.$strict>], "reason">>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodUUID;
+        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<"subagent">;
+        source: z.ZodLiteral<"cezar">;
+        via: z.ZodLiteral<"native-subagents">;
+        deadline: z.ZodISODateTime;
+        children: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                completed: "completed";
+                failed: "failed";
+                running: "running";
+            }>;
+        }, z.core.$strict>>;
+        result: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodEnum<{
+                interrupted: "interrupted";
+                settled: "settled";
+                superseded: "superseded";
+                timeout: "timeout";
+            }>;
+        }, 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>;
+    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>;
+                relationship: z.ZodOptional<z.ZodEnum<{
+                    family: "family";
+                    peer: "peer";
+                }>>;
+                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";
+                    deleted: "deleted";
+                    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";
+                    deleted: "deleted";
+                    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>;
+                revision: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            wakeId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>>;
+        lastWait: 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";
+                    deleted: "deleted";
+                    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>;
+                revision: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            wakeId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>>;
+        results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            workerId: z.ZodUUID;
+            revision: z.ZodNumber;
+            snapshotId: z.ZodUUID;
+            observedAt: z.ZodISODateTime;
+            lastExecutionOutcome: z.ZodEnum<{
+                cancelled: "cancelled";
+                completed: "completed";
+                failed: "failed";
+                "review-ready": "review-ready";
+                running: "running";
+            }>;
+            previous: z.ZodOptional<z.ZodObject<{
+                revision: z.ZodNumber;
+                observedAt: z.ZodISODateTime;
+                lastExecutionOutcome: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    completed: "completed";
+                    failed: "failed";
+                    "review-ready": "review-ready";
+                    running: "running";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        finishRequestedAt: z.ZodOptional<z.ZodISODateTime>;
+        historyDeletion: z.ZodOptional<z.ZodLiteral<"pending">>;
+        completion: z.ZodOptional<z.ZodObject<{
+            phase: z.ZodEnum<{
+                attention: "attention";
+                waiting: "waiting";
+            }>;
+            waitId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        role: z.ZodLiteral<"worker">;
+        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";
+                    deleted: "deleted";
+                    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>;
+                revision: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            wakeId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>>;
+        lastWait: 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";
+                    deleted: "deleted";
+                    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>;
+                revision: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            wakeId: 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";
+        }>>;
+        parentRunId: z.ZodUUID;
+        workspace: z.ZodObject<{
+            ownerRunId: z.ZodUUID;
+            resourceId: z.ZodUUID;
+            kind: z.ZodLiteral<"owned-isolated">;
+            path: z.ZodString;
+            branch: z.ZodString;
+            baselineSha: z.ZodString;
+        }, z.core.$strict>;
+        destroy: z.ZodOptional<z.ZodObject<{
+            requestedAt: z.ZodISODateTime;
+            phase: z.ZodEnum<{
+                cleaning: "cleaning";
+                complete: "complete";
+                incomplete: "incomplete";
+                requested: "requested";
+                terminating: "terminating";
+            }>;
+            remaining: z.ZodArray<z.ZodEnum<{
+                branch: "branch";
+                process: "process";
+                worktree: "worktree";
+            }>>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        context: z.ZodOptional<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+            inputs: z.ZodArray<z.ZodObject<{
+                source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"baseline-file">;
+                    path: z.ZodString;
+                }, 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;
+                bytes: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        executionRevision: z.ZodOptional<z.ZodNumber>;
+        executionStartSeq: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        role: z.ZodLiteral<"invalid">;
+    }, z.core.$strict>], "role">>>;
+    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";
+        codex: "codex";
+        cursor: "cursor";
+        omp: "omp";
+        opencode: "opencode";
+        pi: "pi";
+    }>, z.ZodTransform<"claude" | "codex" | "cursor" | "omp" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "cursor" | "omp" | "opencode" | "pi">>>;
+    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>>>;
+    destroyRetry: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        attempts: z.ZodNumber;
+        nextAt: z.ZodISODateTime;
+        needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>>;
+    stopping: z.ZodCatch<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>>;
+    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";
+            failed: "failed";
+            running: "running";
+        }>;
+        startedAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    archived: z.ZodDefault<z.ZodBoolean>;
+    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;
+        kind: z.ZodEnum<{
+            agent: "agent";
+            check: "check";
+        }>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            pending: "pending";
+            review: "review";
+            running: "running";
+            skipped: "skipped";
+            waiting: "waiting";
+        }>;
+        iterations: z.ZodNumber;
+        retriesUsed: z.ZodOptional<z.ZodNumber>;
+        tokensUsed: z.ZodNumber;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        usageInvocationsStarted: z.ZodOptional<z.ZodNumber>;
+        usageInvocationsObserved: z.ZodOptional<z.ZodNumber>;
+        usageTurnsStarted: z.ZodOptional<z.ZodNumber>;
+        usageTurnsRecorded: z.ZodOptional<z.ZodNumber>;
+        usageInvocationEpoch: z.ZodOptional<z.ZodNumber>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        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";
+            codex: "codex";
+            cursor: "cursor";
+            omp: "omp";
+            opencode: "opencode";
+            pi: "pi";
+        }>, z.ZodTransform<"claude" | "codex" | "cursor" | "omp" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "cursor" | "omp" | "opencode" | "pi">>>;
+    }, z.core.$strip>>;
+    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>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** 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<{
+    archiveWhenDone?: boolean | undefined;
+    autoMergePr?: boolean | undefined;
+    allowWorkers?: boolean | undefined;
+    allowMessaging?: boolean | undefined;
+    id: string;
+    title: string;
+    titleSummary?: string | undefined;
+    diffStat?: {
+        adds: number;
+        dels: number;
+        files: number;
+        repointed?: boolean | undefined;
+    } | undefined;
+    workflow: string;
+    task: string;
+    queuedMessages?: {
+        id: string;
+        text: string;
+        images?: string[] | undefined;
+        createdAt: string;
+    }[] | undefined;
+    continuationMessage?: {
+        id: string;
+        text: string;
+        images?: string[] | undefined;
+        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;
+            relationship?: "family" | "peer" | 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" | "undelivered-question" | undefined;
+        requestHash?: string | undefined;
+        deadline?: string | undefined;
+    }[] | undefined;
+    waits?: ({
+        prUrl: string;
+        repository: string;
+        prNumber: number;
+        headSha: string;
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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" | "merge_or_blocked";
+        wakeOnConflict: boolean;
+        result?: {
+            outcome: "blocked" | "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;
+            mergeBlock?: {
+                reason: "conflict" | "no_pending_merge";
+                isInMergeQueue: boolean;
+                autoMergeEnabled: boolean;
+                event?: {
+                    kind: "auto_merge_disabled" | "queue_removal";
+                    createdAt: string;
+                    reason?: string | undefined;
+                    reasonCode?: string | undefined;
+                } | undefined;
+            } | 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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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" | "deleted" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "peer";
+        deadline: string;
+        timeoutSeconds: number;
+        peerIds: string[];
+        result?: {
+            reason: "message";
+            peerRunId: string;
+            messageId: string;
+        } | {
+            reason: "settled";
+            peerRunId: string;
+        } | {
+            reason: "timeout";
+        } | undefined;
+    } | {
+        id: string;
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "subagent";
+        source: "cezar";
+        via: "native-subagents";
+        deadline: string;
+        children: {
+            id: string;
+            status: "cancelled" | "completed" | "failed" | "running";
+        }[];
+        result?: {
+            reason: "interrupted" | "settled" | "superseded" | "timeout";
+        } | undefined;
+    })[] | undefined;
+    waitRegistrations?: {
+        operationId: string;
+        requestHash: string;
+        wait: {
+            prUrl: string;
+            repository: string;
+            prNumber: number;
+            headSha: string;
+            id: string;
+            source: "agent" | "cezar";
+            via: "ask-line" | "budget" | "cez-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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" | "merge_or_blocked";
+            wakeOnConflict: boolean;
+            result?: {
+                outcome: "blocked" | "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;
+                mergeBlock?: {
+                    reason: "conflict" | "no_pending_merge";
+                    isInMergeQueue: boolean;
+                    autoMergeEnabled: boolean;
+                    event?: {
+                        kind: "auto_merge_disabled" | "queue_removal";
+                        createdAt: string;
+                        reason?: string | undefined;
+                        reasonCode?: string | undefined;
+                    } | undefined;
+                } | 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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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" | "deleted" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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;
+        } | {
+            id: string;
+            source: "agent" | "cezar";
+            via: "ask-line" | "budget" | "cez-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "no-wait" | "schedule-wakeup";
+            registeredAt: string;
+            phase: "cancelled" | "delivered" | "open" | "resolved";
+            resolvedAt?: string | undefined;
+            deliveredAt?: string | undefined;
+            cancelledAt?: string | undefined;
+            turnId: string;
+            kind: "peer";
+            deadline: string;
+            timeoutSeconds: number;
+            peerIds: string[];
+            result?: {
+                reason: "message";
+                peerRunId: string;
+                messageId: string;
+            } | {
+                reason: "settled";
+                peerRunId: string;
+            } | {
+                reason: "timeout";
+            } | undefined;
+        } | {
+            id: string;
+            registeredAt: string;
+            phase: "cancelled" | "delivered" | "open" | "resolved";
+            resolvedAt?: string | undefined;
+            deliveredAt?: string | undefined;
+            cancelledAt?: string | undefined;
+            turnId: string;
+            kind: "subagent";
+            source: "cezar";
+            via: "native-subagents";
+            deadline: string;
+            children: {
+                id: string;
+                status: "cancelled" | "completed" | "failed" | "running";
+            }[];
+            result?: {
+                reason: "interrupted" | "settled" | "superseded" | "timeout";
+            } | undefined;
+        };
+        deduplicated: boolean;
+    }[] | undefined;
+    lastWaits?: ({
+        prUrl: string;
+        repository: string;
+        prNumber: number;
+        headSha: string;
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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" | "merge_or_blocked";
+        wakeOnConflict: boolean;
+        result?: {
+            outcome: "blocked" | "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;
+            mergeBlock?: {
+                reason: "conflict" | "no_pending_merge";
+                isInMergeQueue: boolean;
+                autoMergeEnabled: boolean;
+                event?: {
+                    kind: "auto_merge_disabled" | "queue_removal";
+                    createdAt: string;
+                    reason?: string | undefined;
+                    reasonCode?: string | undefined;
+                } | undefined;
+            } | 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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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" | "deleted" | "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-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "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;
+    } | {
+        id: string;
+        source: "agent" | "cezar";
+        via: "ask-line" | "budget" | "cez-message-wait" | "cez-worker-wait" | "cezar_ask" | "cezar_wait" | "cezar_wait_for_ci" | "completion" | "monitoring-line" | "native-ask" | "native-subagents" | "no-wait" | "schedule-wakeup";
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "peer";
+        deadline: string;
+        timeoutSeconds: number;
+        peerIds: string[];
+        result?: {
+            reason: "message";
+            peerRunId: string;
+            messageId: string;
+        } | {
+            reason: "settled";
+            peerRunId: string;
+        } | {
+            reason: "timeout";
+        } | undefined;
+    } | {
+        id: string;
+        registeredAt: string;
+        phase: "cancelled" | "delivered" | "open" | "resolved";
+        resolvedAt?: string | undefined;
+        deliveredAt?: string | undefined;
+        cancelledAt?: string | undefined;
+        turnId: string;
+        kind: "subagent";
+        source: "cezar";
+        via: "native-subagents";
+        deadline: string;
+        children: {
+            id: string;
+            status: "cancelled" | "completed" | "failed" | "running";
+        }[];
+        result?: {
+            reason: "interrupted" | "settled" | "superseded" | "timeout";
+        } | 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;
+    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;
+    manualUnarchivedAt?: string | undefined;
+    pinned?: boolean | undefined;
+    pinnedAt?: string | undefined;
+    seenAt?: string | undefined;
+    currentStepId?: string | undefined;
+    error?: string | undefined;
+    delegation?: {
+        role: "root";
+        conversation?: {
+            messages: {
+                senderRunId: string;
+                recipientRunId: string;
+                kind: "follow-up" | "progress" | "reply" | "request";
+                requestId?: string | undefined;
+                relationship?: "family" | "peer" | undefined;
+                id: string;
+                text: string;
+                createdAt: string;
+                deadline?: string | undefined;
+                requestHash: string;
+                state: "accepted" | "continuation-required" | "destroyed" | "late";
+                resumed?: true | undefined;
+                instruction?: string | undefined;
+                question?: {
+                    context?: string | undefined;
+                    questions: {
+                        id?: string | undefined;
+                        header: string;
+                        question: string;
+                        options?: {
+                            label: string;
+                            description?: string | undefined;
+                        }[] | undefined;
+                        multiSelect?: boolean | undefined;
+                    }[];
+                } | undefined;
+            }[];
+            outcomes: {
+                requestId: string;
+                status: "cancelled" | "completed-without-reply" | "deleted" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
+                observedAt: string;
+                replyId?: string | undefined;
+            }[];
+        } | undefined;
+        permissions: ("destroy" | "diff" | "inspect" | "spawn" | "steer" | "stop" | "wait")[];
+        receipts: {
+            requestId: string;
+            workerId: string;
+            requestHash: string;
+            deletion?: {
+                phase: "complete" | "pending";
+                revision: number;
+                resourceId: string;
+                generation: string;
+            } | undefined;
+        }[];
+        wait?: {
+            id: string;
+            workerIds: string[];
+            requestIds?: string[] | undefined;
+            requestOutcomes?: {
+                requestId: string;
+                status: "cancelled" | "completed-without-reply" | "deleted" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
+                observedAt: string;
+                replyId?: string | undefined;
+            }[] | undefined;
+            deadline: string;
+            mode?: "all" | "any" | "one" | undefined;
+            revisions?: {
+                workerId: string;
+                revision: number;
+            }[] | undefined;
+            reason?: "cancelled" | "message" | "outcome" | "timeout" | undefined;
+            phase: "parked" | "registered" | "wake-pending";
+            outcomes: {
+                workerId: string;
+                status: "cancelled" | "done" | "failed" | "review";
+                observedAt: string;
+                summary?: string | undefined;
+                revision?: number | undefined;
+            }[];
+            wakeId?: string | undefined;
+        } | undefined;
+        lastWait?: {
+            id: string;
+            workerIds: string[];
+            requestIds?: string[] | undefined;
+            requestOutcomes?: {
+                requestId: string;
+                status: "cancelled" | "completed-without-reply" | "deleted" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
+                observedAt: string;
+                replyId?: string | undefined;
+            }[] | undefined;
+            deadline: string;
+            mode?: "all" | "any" | "one" | undefined;
+            revisions?: {
+                workerId: string;
+                revision: number;
+            }[] | undefined;
+            reason?: "cancelled" | "message" | "outcome" | "timeout" | undefined;
+            phase: "parked" | "registered" | "wake-pending";
+            outcomes: {
+                workerId: string;
+                status: "cancelled" | "done" | "failed" | "review";
+                observedAt: string;
+                summary?: string | undefined;
+                revision?: number | undefined;
+            }[];
+            wakeId?: string | undefined;
+        } | undefined;
+        results?: {
+            workerId: string;
+            revision: number;
+            snapshotId: string;
+            observedAt: string;
+            lastExecutionOutcome: "cancelled" | "completed" | "failed" | "review-ready" | "running";
+            previous?: {
+                revision: number;
+                observedAt: string;
+                lastExecutionOutcome: "cancelled" | "completed" | "failed" | "review-ready" | "running";
+            } | undefined;
+        }[] | undefined;
+        finishRequestedAt?: string | undefined;
+        historyDeletion?: "pending" | undefined;
+        completion?: {
+            phase: "attention" | "waiting";
+            waitId?: string | undefined;
+        } | undefined;
+    } | {
+        role: "worker";
+        wait?: {
+            id: string;
+            workerIds: string[];
+            requestIds?: string[] | undefined;
+            requestOutcomes?: {
+                requestId: string;
+                status: "cancelled" | "completed-without-reply" | "deleted" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
+                observedAt: string;
+                replyId?: string | undefined;
+            }[] | undefined;
+            deadline: string;
+            mode?: "all" | "any" | "one" | undefined;
+            revisions?: {
+                workerId: string;
+                revision: number;
+            }[] | undefined;
+            reason?: "cancelled" | "message" | "outcome" | "timeout" | undefined;
+            phase: "parked" | "registered" | "wake-pending";
+            outcomes: {
+                workerId: string;
+                status: "cancelled" | "done" | "failed" | "review";
+                observedAt: string;
+                summary?: string | undefined;
+                revision?: number | undefined;
+            }[];
+            wakeId?: string | undefined;
+        } | undefined;
+        lastWait?: {
+            id: string;
+            workerIds: string[];
+            requestIds?: string[] | undefined;
+            requestOutcomes?: {
+                requestId: string;
+                status: "cancelled" | "completed-without-reply" | "deleted" | "destroyed" | "failed" | "human-fallback" | "replied" | "replied-late" | "sender-closed" | "timed-out";
+                observedAt: string;
+                replyId?: string | undefined;
+            }[] | undefined;
+            deadline: string;
+            mode?: "all" | "any" | "one" | undefined;
+            revisions?: {
+                workerId: string;
+                revision: number;
+            }[] | undefined;
+            reason?: "cancelled" | "message" | "outcome" | "timeout" | undefined;
+            phase: "parked" | "registered" | "wake-pending";
+            outcomes: {
+                workerId: string;
+                status: "cancelled" | "done" | "failed" | "review";
+                observedAt: string;
+                summary?: string | undefined;
+                revision?: number | undefined;
+            }[];
+            wakeId?: string | undefined;
+        } | undefined;
+        permissions: ("destroy" | "diff" | "inspect" | "spawn" | "steer" | "stop" | "wait")[];
+        parentRunId: string;
+        workspace: {
+            ownerRunId: string;
+            resourceId: string;
+            kind: "owned-isolated";
+            path: string;
+            branch: string;
+            baselineSha: string;
+        };
+        destroy?: {
+            requestedAt: string;
+            phase: "cleaning" | "complete" | "incomplete" | "requested" | "terminating";
+            remaining: ("branch" | "process" | "worktree")[];
+            error?: string | undefined;
+        } | undefined;
+        context?: {
+            text?: string | undefined;
+            inputs: {
+                source: {
+                    kind: "parent-file";
+                    path: string;
+                } | {
+                    kind: "baseline-file";
+                    path: string;
+                } | {
+                    kind: "parent-attachment";
+                    id: string;
+                };
+                path: string;
+                sha256: string;
+                bytes: number;
+            }[];
+        } | undefined;
+        executionRevision?: number | undefined;
+        executionStartSeq?: number | undefined;
+    } | {
+        role: "invalid";
+    } | undefined;
+    lastWaitsError?: string | undefined;
+    automaticWakes?: number | undefined;
+    waitDeliveryFailures?: number | undefined;
+    runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+    notify?: boolean | undefined;
+    webhook?: {
+        lastDeliveredAt?: string | undefined;
+        lastError?: string | undefined;
+        lastErrorWebhookId?: string | undefined;
+    } | undefined;
+    destroyRetry?: {
+        attempts: number;
+        nextAt: string;
+        needsAttention?: true | undefined;
+    } | undefined;
+    stopping?: boolean | undefined;
+    hasPendingPermission?: boolean | undefined;
+    autoResumeAt?: string | undefined;
+    autoResumeAttempts?: number | undefined;
+    pullRequests?: {
+        number: number;
+        url?: string | undefined;
+        source: "created" | "declared";
+    }[] | undefined;
+    worktreeSetup?: {
+        status: "done" | "failed" | "running";
+        startedAt: string;
+        finishedAt?: string | undefined;
+        durationMs?: number | undefined;
+        error?: string | undefined;
+    } | undefined;
+    archived: boolean;
+    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;
+        kind: "agent" | "check";
+        status: "cancelled" | "done" | "failed" | "pending" | "review" | "running" | "skipped" | "waiting";
+        iterations: number;
+        retriesUsed?: number | undefined;
+        tokensUsed: number;
+        inputTokens?: number | undefined;
+        outputTokens?: number | undefined;
+        usageInvocationsStarted?: number | undefined;
+        usageInvocationsObserved?: number | undefined;
+        usageTurnsStarted?: number | undefined;
+        usageTurnsRecorded?: number | undefined;
+        usageInvocationEpoch?: number | undefined;
+        startedAt?: string | undefined;
+        finishedAt?: string | undefined;
+        error?: string | undefined;
+        sessionId?: string | undefined;
+        sessionTransport?: "cursor-acp" | "cursor-print" | undefined;
+        profileId?: string | undefined;
+        costUsd?: number | undefined;
+        synthetic?: "continuation" | undefined;
+        backend?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+    }[];
+    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;
+        }[];
+    } | undefined;
+}[]>;
+/** One stored record and what its JSON holds beyond the runtime schema (raw-record.ts), which
+ *  the next write of its row puts back. */
+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. */
+export declare function decodeRunRow(data: string): DecodedRun | undefined;
+/** One database row's `data` back into a record, for a reader that never writes it back. */
+export declare function decodeRunRecord(data: string): RunRecord | undefined;
+export { LEGACY_INDEX_BACKUP_FILE, LEGACY_INDEX_FILE } from './legacy-index.ts';
+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 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. */
+export declare const ARCHIVED_WINDOW = 200;
+/** The repository a project IS, as `resolveRepoHandle` reports it. `null`/absent means "unknown",
+ *  which is a real and common state (no `gh`, no remote, a non-git root) — never an error. */
+export type RepoHandle = {
+    owner: string;
+    name: string;
+};
+/**
+ * Reconcile one record just read off disk with the fact that whichever process wrote it is gone.
+ *
+ * Mutates and returns `run`. Extracted from `RunStore.open` so the read-only index reader
+ * (`./run-index.ts`) answers the SAME question about a `running` row on disk. Two parsers that
+ * disagree here is a visible bug, not an internal one: the cockpit would show a task as running
+ * in the ⌘K index and failed the moment you opened it.
+ *
+ * `keepLive` (#367): leave `queued`/`running`/`waiting` untouched so the caller can recover them
+ * (RunManager.recover re-queues queued runs, resumes interrupted ones). Without it — one-shot CLI
+ * paths that never recover, and the index reader, which has no manager at all — live-looking runs
+ * are marked failed so no ghost stays behind.
+ */
+export declare function reconcileLoadedRun(run: RunRecord, opts?: {
+    keepLive?: boolean;
+}): RunRecord;
+/**
+ * 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 | undefined;
+}): RunRecord;
+export declare function __setLegacyImportHookForTests(hook?: {
+    beforeTransaction?: () => void;
+    beforeCommit?: () => void;
+}): void;
+/** What branch cleanup and git-log attribution read about a run (`RunStore.listBranchOwners`). */
+export interface BranchOwner {
+    id: string;
+    title: string;
+    status: RunStatus;
+    archived: boolean;
+    createdAt: string;
+    /** The branch the run owns (see `encodeRunRow`); absent for a run listed for its PR alone. */
+    branch?: string;
+    baseBranch?: string;
+    pullRequestUrl?: string;
+}
+/** A record as a branch owner, or undefined when it owns no branch and created no PR: the
+ *  projection `listBranchOwners` reads off a row's summary and columns, computed from memory. */
+export declare function branchOwnerOf(run: RunRecord): BranchOwner | undefined;
+/** Who may hold a run in memory besides its own record (see `RunStore.pin`). `maintenance` is the
+ *  RunManager's publish, worktree-reclaim and branch-cleanup claims, held across their async work. */
+export type RunPinHolder = 'active' | 'continue' | 'cleanup' | 'maintenance';
+/**
+ * Who may change a run, as this store sees it (#779, plan step 3; `RunStore.runOwnership`):
+ * - `held`: this store claims its delegation family;
+ * - `free`: no live process claims it and nothing in its family is live; a write takes it. A
+ *   proven-dead owner's claim on such a family counts for nothing: there is nothing to recover;
+ * - `orphaned`: nobody alive owns a family that still has a live run (its owner died, or nobody
+ *   claimed it): taking it means adopting it first (`RunStore.adoptFamily` settles it, then the
+ *   manager recovers the family);
+ * - `foreign`: another process that is alive (or cannot be proven dead) holds it: read-only here;
+ * - `quarantined`: a write found it changed under this store; refused until cezar restarts;
+ * - `fallback`: a family member is read from the fallback directory: refused as `foreign` until a control adopts it.
+ */
+export type RunOwnership = 'held' | 'free' | 'orphaned' | 'foreign' | 'quarantined' | 'fallback';
+/** The one answer every control gives for a run another cezar process owns (`409 { error }`). */
+export declare const RUN_IN_USE_ELSEWHERE: string;
+/** The answer for a run this process stopped writing after a conflicting write. */
+export declare const RUN_QUARANTINED: string;
+/** A write this store must not make: another process owns the run, its owner died with work
+ *  still live (adopt it first), or a conflict quarantined it. Nothing was changed. */
+export declare class RunWriteRefusedError extends Error {
+    readonly runId: string;
+    readonly ownership: Exclude<RunOwnership, 'held' | 'free'>;
+    constructor(runId: string, ownership: Exclude<RunOwnership, 'held' | 'free'>, fallbackError?: string);
+}
+/** 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 or nothing durable changed
+ *  (`republish`) (in-process only). */
+export type CommitSource = 'delegation-checkpoint' | 'delegation-destroy-progress' | 'live-release';
+/**
+ * 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;
+    /** The held set: every record this store keeps in memory, by id. */
+    private readonly held;
+    /** Who holds a run beyond its record, by holder, so one holder's unpin never releases another. */
+    private readonly pins;
+    /** Staged ids while a durable commit installs and announces them: never evicted mid-commit. */
+    private readonly committing;
+    private saveTimer;
+    /** `null` once the store is closed, and in a `RunStore.unavailable` store (nothing is written,
+     *  nothing is evicted). */
+    private db;
+    get reports(): ReportsIndex;
+    /** Why `open` failed, in a `RunStore.unavailable` store. */
+    private openFailure;
+    private persistence;
+    /** Runs whose held record is ahead of its row; the next save or commit writes them. */
+    private readonly dirty;
+    /** The lifecycle events run exits write (B12). */
+    private readonly exitEvents;
+    /** Runs gone from memory whose rows the next save or commit deletes. */
+    private readonly deleted;
+    /** Deleted runs whose history files (events, handoff, images, artifacts) go once the delete of
+     *  their row commits: until then a conflict can undo the delete and bring the row back. */
+    private readonly historyOwed;
+    /** The repository this project IS (#945), armed after `open()` by `setRepoHandle`. Undefined
+     *  until it arrives and `null` when it cannot be known — both mean "unscoped", which is
+     *  exactly the pre-#945 behavior. */
+    private repoHandle;
+    /** `open()`'s `keepLive`, which a run read later from `runs.db` is reconciled with too. */
+    private keepLive;
+    /** This store's identity in `run_claims`; undefined without a database. */
+    private owner;
+    /** The families this store claims, with the generation each acquisition got. */
+    private readonly claimed;
+    /** Families judged free whose claim a busy database kept this store from taking: the next write
+     *  of their rows takes it in its own transaction, if it is still as judged (null: absent). */
+    private readonly pendingClaims;
+    /** The revision and `data` of each held row (and pending deletion) as this store last read or
+     *  wrote it: what a write is fenced against, and a conflict's "original". No entry: this store
+     *  created the row and has not written it yet. `extras` is what that `data` holds beyond the
+     *  schema, which the next write of the row puts back (raw-record.ts). */
+    private readonly base;
+    /** Rows read cold in the current synchronous turn, so a commit staged from one is fenced against
+     *  the version it was computed from. `owned`: its family was already this store's when read.
+     *  Cleared at the next microtask: no commit spans a turn. */
+    private readonly coldBase;
+    private readonly coldReads;
+    /** The family of each pending deletion, whose claim the deleting write is fenced against. */
+    private readonly deletedFamilies;
+    /** Rows a conflicting write excluded: this store refuses to write them until it is reopened. */
+    private readonly quarantined;
+    /** Rows whose `data` this store tried to decode and could not: left in the database untouched,
+     *  and left out of the list rows from then on, as the cold reader leaves them out (run-index.ts). */
+    private readonly unreadable;
+    /** Background one-at-a-time compressor for archived transcripts (#818). */
+    private readonly compressor;
+    /** Transcript facts the delegation paths ask about, so they never re-read a transcript (#880). */
+    private readonly facts;
+    private readonly liveItems;
+    private fallbackFacts;
+    private factsFor;
+    /** 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
+     * about live-looking rows.
+     *
+     * Reads `runs.db` once its import is complete. Before that, `runs.json` is imported into it in
+     * one transaction (`importLegacyIndex`) and left exactly as it was, for older cezars to read.
+     * Either way only the held set is decoded: the live rows (by the indexed `live` column), the
+     * few finished rows a normalization still repairs, and the delegation families of the live
+     * ones.
+     *
+     * A store that cannot be opened is never an empty one (#779, plan step 4): `open` throws a
+     * `RunStoreOpenError` naming the cause, and nothing is reset, restored or deleted. `retryBusy`
+     * waits out a busy database (and a cockpit that may still be importing) with growing pauses,
+     * about 3.5 s in all, before it gives up. Open is synchronous, so the wait blocks this thread:
+     * only a boot passes it, while nothing else runs yet. Without it a busy database fails after
+     * one busy timeout.
+     */
+    static open(dataDir: string, opts?: {
+        keepLive?: boolean | undefined;
+        retryBusy?: boolean;
+        maintenance?: boolean;
+        persist?: RunStorePersistence;
+    }): RunStore;
+    private static openOnce;
+    /**
+     * The store `serve` keeps for its boot project when `open` failed: no database, nothing held,
+     * and every attempt to create or save a run refused with `failure`. The cockpit answers every
+     * route of that project with `failure`'s message, and boot skips everything that would read
+     * its empty run list as "no runs" (orphan pruning, retention, recovery, scratch sweeps). The
+     * way out is a restart once the cause is gone.
+     */
+    static unavailable(dataDir: string, failure: RunStoreOpenError): RunStore;
+    /** Why this store has no database, when it is `RunStore.unavailable`'s: its runs are unknown,
+     *  not absent. */
+    get unavailable(): RunStoreOpenError | undefined;
+    /** Every sidecar for a run follows the winning record, never file-by-file fallback. */
+    sourceDataDir(id: string): string;
+    isFallbackRun(id: string): boolean;
+    hasFallbackRun(id: string): boolean;
+    fallbackDeleteError(id: string, kind?: 'record' | 'worktree'): string | undefined;
+    /**
+     * Open-time load: the live rows, the finished rows a load normalization repairs, then the
+     * delegation families of the live ones. A row that does not parse is skipped and left in the
+     * database untouched; one warning says how many.
+     *
+     * Only rows this store can claim are loaded (#779, plan step 3). A live row whose family another
+     * live process claims — `serve`'s parked run, seen by a headless `cez run` — is that process's:
+     * it is not loaded, normalized or recovered here, and stays readable through `getRun` and the
+     * list rows. A live row nobody alive claims is taken over, as before: this open recovers it
+     * (`keepLive`) or settles it as interrupted.
+     */
+    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. 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
+     * `parent_run_id` index. No recursion: workers cannot delegate, so a worker's own id never
+     * names a family. The caller has claimed it. `settle` settles its live rows instead of keeping
+     * them for recovery (`settleOrphanedRun`); `stopId` is the run a Stop settles as cancelled.
+     */
+    private holdFamily;
+    /** Make sure this store claims each of `families`; `claimStoreFamilies` takes the free ones. */
+    private claimFamilies;
+    /** Release the claim of every family with nothing left in memory, once nothing is pending: a
+     *  failed save keeps its families claimed until it succeeds. A failed release retries at the
+     *  next sweep; `close()` releases the rest. */
+    private releaseUnheldClaims;
+    /**
+     * Who may change this run right now (see `RunOwnership`), or undefined when there is no such
+     * run. Read-only: nothing is claimed. Controls ask this first, so a run another process owns is
+     * refused with `RUN_IN_USE_ELSEWHERE` and a dead process's run is adopted before it is changed.
+     */
+    runOwnership(id: string): RunOwnership | undefined;
+    /** Why a control on this run must be refused here, or undefined when this store may change it. */
+    writeRefusal(id: string): string | undefined;
+    /**
+     * Claim an orphaned family before a control, then settle its live rows.
+     * Stop cancels its target. Return the root id, or undefined for a live owner or missing run.
+     */
+    adoptFamily(id: string, opts?: {
+        stop?: boolean;
+    }): string | undefined;
+    /** Explicit controls only (`requireRunControl`): copy a fallback family in so it can be written. */
+    adoptFallbackFamily(id: string): boolean;
+    private fallbackRefusal;
+    /** Run files are written only for a family this store may write, never a fallback family. */
+    private writeDir;
+    /** Every run whose family another process owns (`foreignClaimedRunIds`). */
+    listForeignClaimedRunIds(): string[];
+    /** Non-terminal rows in the database (both directories) and the runs of families another live store claims. */
+    persistedLiveRunIds(): {
+        live: string[];
+        foreign: string[];
+    };
+    /**
+     * Whether a held run anchors itself (and its family) in memory. Anything else held is a family
+     * member or a settled write, and leaves at the next sweep (`evictSettled`).
+     *
+     * The held set is: every run that is live (`isLiveRecord`), pinned by a RunManager (`pin`),
+     * dirty, or inside a durable commit; plus the whole delegation family (root and direct
+     * workers) of any such run. Families are held because the RunManager reads a live run's family
+     * on every run event — `GET /runs/:id/relationships`, the global `reconcileWorkerWaits` pass
+     * (about twenty call sites), completion blockers and conversations — and decoding a cold
+     * record costs about 200 µs (JSON.parse plus the schema). Measured on a copy of a real
+     * cockpit's `runs.json` (958 runs, 957 of them delegated): a running root with 26 workers
+     * paid about 5 ms per family read, and the live families together about 10 ms per global
+     * pass, all on the event loop. Holding them costs memory in proportion to active work, not to
+     * history.
+     */
+    private isAnchor;
+    /** The family roots with an anchoring member in memory. */
+    private anchoredFamilies;
+    /** Drop every held run that is neither an anchor nor in an anchored family. A store without a
+     *  database keeps everything: memory is the only copy it has. */
+    private evictSettled;
+    /** A run read from `runs.db`, normalized like a loaded one (`reconcileLoadedRun`, then the
+     *  repository scope) but held by nobody. Undefined when absent, deleted or unreadable. */
+    private loadCold;
+    private decodeCold;
+    /** Hold a writable row. A fallback family's reads stay detached (the cold-read contract). */
+    private holdDecoded;
+    /**
+     * Hold a claimed run for a write; leave after settlement unless anchored.
+     * Take the family claim before reading its row. Return undefined for a live foreign owner
+     * or a fallback family: neither claim is granted.
+     */
+    private hold;
+    /** The record a store write changes in place: held, or loaded to be. Undefined for a run this
+     *  store may not write (another process's, or quarantined), so the write changes nothing. */
+    private record;
+    /** Read held legacy family members, or a detached cold record. */
+    private peek;
+    /**
+     * A run just read off its row, as reads answer it: held when its family is in memory (a live
+     * family's members are read on every run event), else a copy nobody holds — frozen under
+     * vitest when it leaves the store (`freeze`).
+     */
+    private answerCold;
+    /** `getRun` for a row a query already read: the held object, else decoded from `row`. */
+    private fromRow;
+    /** Run `fn` reading each run that is not held at most once (`ColdReadCache`, hearsay-tools/cezarion#2378). */
+    withReadCache<T>(fn: () => T): T;
+    /** Whether the run exists, held or not, without decoding it. */
+    private hasRun;
+    /**
+     * Keep a run in memory for `holder` until `unpin(id, holder)`: a RunManager pins the runs it is
+     * executing (`active`) and the run a Continue is admitting (`continue`). A finished run is
+     * 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;
+    /**
+     * 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. */
+    private storedScopeDiffers;
+    /**
+     * 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`, `listRunsWithWorktree`,
+     * `listBranchOwners`), or as list rows (`listRunSummaries`).
+     */
+    listRuns(): RunRecord[];
+    /** Where a held run lists: its row's insertion order, or after every row while this store has
+     *  not written it yet. The held set keeps such runs in creation order, and so does every list
+     *  that sorts them in held-set order (`sortNewestFirst` is stable). */
+    private listOrder;
+    /**
+     * EVERY run as a full record, newest first — decoded row by row. Only the legacy `GET /runs`
+     * (older clients; the cockpit reads `GET /run-summaries`) may call this: it is exactly the
+     * whole-history parse #779 exists to remove from everything else.
+     */
+    listAllRunsForLegacyRoute(): RunRecord[];
+    /** A bounded page of discoverable peer roots, including the current held overlay. */
+    listPeerTaskSummaries(options: PeerTaskPageOptions): {
+        runs: RunSummary[];
+        nextOffset?: number;
+    };
+    /**
+     * Every run as its list row, newest first: the stored `summary` column, with each held run's
+     * own projection laid over it — a debounced save keeps memory up to 300 ms ahead of the row,
+     * and a run created since the last save has no row yet. `usage` is the caller's to attach.
+     *
+     * With `archivedWindow` (#864), the window the cockpit's lists read: every unarchived run, plus
+     * the newest `archivedWindow` archived ROOT runs, and whether older archived roots were left
+     * out. Archived workers are never in it (see `RunDatabase.listWindowSummaries`); with `roots`,
+     * no worker is — the runs index, whose readers list no workers. A held run
+     * lists by its record, so one archived or unarchived since the last save is ranked as it is now.
+     *
+     * A row this store found unreadable is left out, as the cold reader leaves out a row it had to
+     * decode and could not. A finished row nobody has decoded is served from its summary by both,
+     * which decodes nothing; reading it is what finds out (`isUnreadable`).
+     */
+    listRunSummaries(options?: {
+        archivedWindow?: number | undefined;
+        roots?: boolean;
+    }): {
+        runs: RunSummary[];
+        truncated: boolean;
+    };
+    /**
+     * 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. `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.
+     */
+    listArchivedRuns(options: {
+        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` (`matchesRunSearch`), newest first: at most
+     * `limit`, and whether more matched. The owned half of the workspace search (#864); held runs
+     * match by their record.
+     */
+    searchRunSummaries(query: string, limit: number): {
+        runs: RunSummary[];
+        truncated: boolean;
+    };
+    /** A row whose stored summary does not fit the contract any more, projected from its record. */
+    private coldSummary;
+    /**
+     * The run, or undefined. A held run is the held object (writes install into it). Any other run
+     * is a fresh copy of its row each call, normalized like a loaded record — frozen under vitest —
+     * so changing it means a store method, never an assignment.
+     */
+    getRun(id: string): RunRecord | undefined;
+    /** Whether the run's row is in `runs.db` but its record could not be read here: what tells a
+     *  run that cannot open from one that does not exist. Known once something tried to read it. */
+    isUnreadable(id: string): boolean;
+    /** The ids in memory right now: the held set, for diagnostics and the benchmark's heap pass. */
+    heldIds(): string[];
+    /**
+     * The workers a root run owns, newest first, read off its own `receipts` (#659). Every
+     * `createOwnedRun` writes the receipt and the worker record in one transaction, and the
+     * receipt list is capped at 1,024 creations (#816), so this is a bounded lookup rather than a walk of the whole
+     * project index. An ordinary or worker run owns nothing and costs one map read; a receipt
+     * whose record has been deleted is skipped, never invented. A parent quarantined to
+     * `invalid` has no readable receipts and reports none, which is also what the cockpit
+     * assumes for that role.
+     */
+    listOwnedWorkers(parentId: string): RunRecord[];
+    /** Every worker filed under `parentId` (the `parent_run_id` index plus memory), newest first:
+     *  receipts or not, which is what the reconcile and deletion checks ask. */
+    listWorkersOf(parentId: string): RunRecord[];
+    /** The id of every worker, held or stored, without decoding any (recovery's worker passes). */
+    listWorkerIds(): string[];
+    /** 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
+     * pass over `runs.db` that reads the records' JSON in SQLite — only a crash leftover (a
+     * receipt still `reserved` at startup) ever asks.
+     */
+    findRunIdsByAutomationReceipt(receiptIds: readonly string[]): Map<string, string>;
+    /** The id of every root whose delegation carries a conversation, held or stored: recovery's full
+     *  reconcile pass (#661). Only roots' records are read, in SQLite. `naming` keeps the ledgers whose
+     *  messages name that run id, filtered there too, so a deleted peer decodes no other root. */
+    listConversationRootIds(naming?: string): string[];
+    /** The id of every run, held or stored, without decoding any (orphan-worktree sweeps). */
+    listRunIds(): string[];
+    /** Runs with a materialized worktree directory (`worktreePath`, not reclaimed), most recently
+     *  finished first, then newest first: worktree retention and the worktrees panel. */
+    listRunsWithWorktree(): RunRecord[];
+    /**
+     * Every run that owns a branch or names the PR it created, as the few fields branch cleanup and
+     * git-log attribution read (issue 08 §B3, §B5; a squash commit is attributed by its PR number):
+     * the stored summary plus the `branch` and `base_branch` columns, so a Git-tab request decodes
+     * no record. Held runs answer from memory.
+     */
+    listBranchOwners(): BranchOwner[];
+    /** The rows a column query returned, as records, with memory laid over them: a held run
+     *  answers from memory (matching `matches` there, not on its maybe-older row). */
+    private queryRuns;
+    /** The run an idempotent start already created (#504), archived or not. A deleted run is gone
+     *  with its record, so a retry after deletion honestly creates a fresh one. */
+    findRunByClientRequestId(clientRequestId: string): RunRecord | undefined;
+    createRun(input: Pick<RunRecord, 'allowWorkers' | 'allowMessaging'> & {
+        title: string;
+        systemPrompt?: string | undefined;
+        workflowDef?: z.infer<typeof workflowDefSchema>;
+        workflow: string;
+        task: string;
+        model?: string | undefined;
+        /** Reasoning-effort pin (#45). Absent = harness default. */
+        effort?: string | undefined;
+        runner?: RunnerId | undefined;
+        /** Composer's per-task agent account (spec 2026-07-29-agent-profiles). */
+        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 | undefined;
+        worktree?: false | undefined;
+        groupId?: string;
+        variant?: 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. */
+    private buildRun;
+    /** Accept the family ledger and its recipient queue in a single durable index replacement. A new
+     *  message (`message`, or the delivered input) whose ID is in use writes nothing; `recipientDelegation`
+     *  makes a peer recipient with no delegation record a root task in the same write. */
+    commitConversation(rootId: string, conversation: ConversationState, delivery?: {
+        recipientRunId: string;
+        input: AgentInput;
+        recipientDelegation?: DelegationState;
+    }, message?: ConversationIdentity): 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[];
+    /** 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;
+    /**
+     * 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, registration?: WaitRegistrationReceipt): void;
+    /** Record a deduplicated registration without mutating its wait. */
+    commitWaitRegistration(id: string, receipt: WaitRegistrationReceipt): 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` by
+     *  the `withdraw-hold` exit; any other run only loses its resume fields. */
+    commitAutoResumeWithdrawal(id: 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;
+    }): OutcomeReceipt;
+    /** An acknowledged inactive-root Finish must survive the async diff and restart. */
+    commitRootFinishIntent(id: string): void;
+    /** Persist all authority patches before exposing any of them to the engine or subscribers. */
+    commitDelegation(patches: ReadonlyArray<{
+        id: string;
+        delegation: DelegationState;
+    }>): void;
+    /** A pending destroy's automatic retry state, or its removal (hearsay-tools/cezarion#879). Kept on
+     * the record beside the strict delegation, so an older cezar strips it rather than quarantining the
+     * worker. Destroy progress: nothing the family reconcile reads changes. */
+    commitDestroyRetry(id: string, retry: WorkerDestroyRetry | undefined): void;
+    /** Accepted execution revision is public lifecycle identity, separate from process generations. */
+    commitWorkerContinuation(id: string, exit: RunExitId, patch?: Omit<RunPatch, 'delegation'>, step?: Pick<StepState, 'id' | 'name' | 'kind' | 'synthetic'>, conversation?: {
+        rootId: string;
+        state: ConversationState;
+        input: AgentInput;
+    }): void;
+    private workerResultsDir;
+    workerResultSnapshotPath(parentId: string, workerId: string, snapshotId: string): string;
+    private readWorkerResultFile;
+    readWorkerResult(parentId: string, workerId: string): WorkerCollectedResult | undefined;
+    readWorkerResultDiff(parentId: string, workerId: string): string | undefined;
+    /** Publish a pointer only after its redacted immutable snapshot reaches disk. */
+    commitWorkerResult(parentId: string, value: WorkerCollectedResult, diffSnapshot?: string, opts?: {
+        ignoreCleanup?: boolean;
+    }): WorkerCollectedResult;
+    /** Create an owned worker run and its parent receipt; `createStoreOwnedRun` holds the checks. */
+    createOwnedRun(input: Parameters<RunStore['createRun']>[0], parentId: string, requestId: string, worker: DelegationState, requestHash: string, executionIdentity?: WorkerExecutionIdentity): RunRecord;
+    /**
+     * 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;
+    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
+     * left it live and it has not been adopted.
+     */
+    private assertWritable;
+    /** The family of a run this store knows: held, else its row; a run nowhere is its own. */
+    private familyOf;
+    /** Schedule the sweep that lets any of `ids` leave memory, when one of them now can. */
+    private sweepIfSettled;
+    /** Move run `id` by `exit` (ADR 0056): its status and `extras` in one write, checked against the
+     *  record that write changes. A run this store cannot write is neither checked nor written. The
+     *  exit decides how the write persists (`exitDurability`), never the extras. A guarded exit (one
+     *  with a `guard` or a `settle`) commits at once, and writes nothing when its guard fails: undefined, or its
+     *  `refused` error. `call` names the step the exit settles apart from the others, and the text
+     *  of the lifecycle event it writes after the write (`exitEvent`). */
+    move(id: string, exit: RunExitId, extras?: RunPatch, call?: ExitCall): RunRecord | undefined;
+    /** A write that is not a run exit. It commits at once when it changes handoff records, a
+     *  completion option or task access, else the next save writes it. A status in the patch, which only test
+     *  fixtures still write, takes the exit's record rule (`doneCommits`). */
+    updateRun(id: string, patch: RunPatch): RunRecord | undefined;
+    /** One update of the held record `run`: committed at once, or written to the record for the next
+     *  save. A debounced write is best-effort, so a locked database cannot stop cleanup. */
+    private writeRun;
+    private redactPatch;
+    /** 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;
+    private applyArchived;
+    /** Transcript form follows `archived`: enqueue compression, or restore the plain file now. */
+    private syncTranscriptForm;
+    /**
+     * Whether this store may compress `id`'s transcript: the run exists, is archived, is not in a
+     * live status (queued/running/waiting), and this process holds the family's claim in `claimed`
+     * (not merely `pendingClaims`). Two processes never both write a run (#779, #818 B1).
+     */
+    private isHistoryCompressEligible;
+    /** Take the family claim if free and require it to be in `this.claimed`, not only pending. */
+    private holdsCompressClaim;
+    /** Startup sweep: enqueue every archived non-live run that still has a plain transcript. */
+    compressArchivedHistory(): void;
+    /** Resolves when the transcript compressor is idle (tests, shutdown). */
+    historyIdle(): Promise<void>;
+    /** Pin one run to the top of this project's task list, or unpin it (#935). Mirrors
+     *  `setArchived`: sets the fields, then persists + broadcasts via `touch`, so the updated
+     *  record rides the existing `run` SSE with no new event. Idempotent — re-pinning a pinned
+     *  run just re-stamps `pinnedAt`.
+     *
+     *  Every active status is pinnable. Archived requests clear stale metadata instead, so a
+     *  late click racing archive cannot leave a hidden pin that reappears on unarchive. */
+    setPinned(id: string, pinned: boolean): RunRecord | undefined;
+    /** 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, automation?: boolean): {
+        archived: number;
+        ids: string[];
+        pinnedIds: string[];
+    };
+    /** Mark one run as read (#unread-done-items): stamp the read receipt now. Mirrors
+     *  `setArchived` — sets the field then persists + broadcasts via `touch`, so the
+     *  updated record rides the existing `run` SSE with no new event. Idempotent by
+     *  design: opening an already-read thread just re-stamps a later `seenAt`. */
+    setRead(id: string): RunRecord | undefined;
+    /** Mark one run as UNread (#775): drop the read receipt so the run rejoins the unread
+     *  list. The inverse of `setRead` and, like it, `touch`es so the updated record rides the
+     *  existing `run` SSE.
+     *
+     *  Deleting the field rather than adding a "manually unread" flag is the whole point:
+     *  absent `seenAt` is ALREADY what every reader treats as unread (`isUnread` in the
+     *  cockpit's read-state.ts, and `markAllRead`'s clause-for-clause copy of it below), so
+     *  clearing needs no new state and writes a shape any older cezar already parses.
+     *
+     *  Deliberately unconditional: clearing a receipt is always a legal write, so this
+     *  succeeds for an already-unread run (idempotent) and for statuses that can never wear
+     *  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;
+    /**
+     * 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 | undefined;
+        [key: string]: unknown;
+    }): RunEvent;
+    /**
+     * 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 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.
+     *
+     * One declaration is NOT a statement about the referenced tier: the number of the PR this run
+     * itself created. See `referencedPrDeclaration` — the marker contract asks the agent to
+     * 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 | 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. 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;
+        stepId?: string;
+        [key: string]: unknown;
+    }): RunEvent;
+    /** Lazily-collected concrete secret values from the host env (#427). */
+    private secretValues;
+    /** Controller-issued tokens never persist, including when host-secret redaction is disabled. */
+    private readonly sessionSecrets;
+    registerSessionSecret(value: string): void;
+    containsSessionSecret(value: string): boolean;
+    /**
+     * Scrub known credential values / token shapes from an event before it is
+     * persisted or fanned out. On by default; `CEZ_REDACT_SECRETS=0` opts out.
+     */
+    private redact;
+    /** Best-effort scrub of one free-text string bound for `runs.json`. Honors
+     *  the `CEZ_REDACT_SECRETS=0` opt-out itself so every caller inherits it. */
+    redactText(text: string): string;
+    private hostSecrets;
+    /** 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;
+    /** 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[]>;
+    readEvents(runId: string): RunEvent[];
+    /** Private process-generation evidence; never part of run JSON or SSE. */
+    private identityPath;
+    readWorkerIdentity(id: string): WorkerExecutionIdentity | undefined;
+    private writeWorkerIdentity;
+    private executionPath;
+    readWorkerExecution(id: string): WorkerExecution | undefined;
+    private writeWorkerExecution;
+    /** Complete execution is not permission to reuse/delete persistent resources (#738).
+     * Synchronous, fresh and generation/resource fenced; callers hold admission off across awaits. */
+    workerResourcesSafe(id: string, generation: string, resourceId: string, admittingQueued?: boolean): boolean;
+    /** `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 | 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. */
+    retainWorkerScratchCleanup(id: string): void;
+    /** Cleanup can outlive its index row, but never its generation or terminal task intent.
+     * `cwds` is the scratch reprobe tick's shared `/proc` snapshot (hearsay-tools/cezarion#879). */
+    workerScratchResourcesSafe(id: string, generation: string, resourceId: string, cwds?: CwdSource): boolean;
+    commitWorkerExecutionStart(id: string): string;
+    /** Private process record (#469): which processes a generation spawned, never part of run JSON or SSE. */
+    private processesPath;
+    /** Tri-state: only ENOENT is `absent` (legacy, scan-only). A present record that is unreadable,
+     * wrongly permissioned, malformed or of another generation is `unknown`: never finalized or reaped. */
+    readWorkerProcesses(id: string, generation: string): WorkerProcessRecord | 'absent' | 'unknown';
+    private writeWorkerProcesses;
+    /** Bound to the current generation. Past the cap the record never drops an entry: the
+     * working-directory scan is the remaining evidence. */
+    appendWorkerProcess(id: string, generation: string, pid: number, pgid?: number): boolean;
+    commitWorkerExecutionComplete(id: string, generation: string): boolean;
+    /** Complete replacement evidence can stand in for absent child history, never for a present execution. */
+    readDeletedWorkerResult(parentId: string, workerId: string): WorkerCollectedResult | undefined;
+    /** A deleted child's receipt replaces the private proof only after the deletion checkpoint. */
+    private workerDeletionEvidence;
+    private workerDeletionResult;
+    canDeleteRun(id: string, kind?: 'record' | 'worktree'): boolean;
+    /** Delegated history deletion is synchronous and checkpointed; any failed byte/index removal remains retryable. */
+    private deleteDelegatedRun;
+    private removeRunHistoryBytes;
+    deleteRun(id: string): boolean;
+    /** Write the pending rows out now (used on shutdown). */
+    flush(): void;
+    private seqs;
+    private nextSeq;
+    /** After a restart the in-memory counter is empty while the run's NDJSON file
+     *  keeps the history. Restarting from 1 would collide with the seqs a client
+     *  already replayed — its `seq > maxSeq` dedup then silently drops every
+     *  resumed event, even across a reload (the frozen-transcript symptom class
+     *  of #424). One file read on the first post-restart append per run. */
+    private rehydrateSeq;
+    private eventsPath;
+    /** Same location `handoffPath()` in handoff.ts produces — inlined to keep
+     *  the store free of upward imports. */
+    private handoffPath;
+    /** Agent screenshots persisted by the run manager (see persistImage). */
+    private imagesDir;
+    private touch;
+    /** Form follows archived: a terminal archived run with a plain transcript is queued again. */
+    private maybeEnqueueHistoryCompress;
+    /** The held record is gone; the next save or commit deletes its row, fenced by `family`'s claim
+     *  and by the revision this store last saw (kept in `base` until the delete is written). */
+    private markDeleted;
+    /** A deleted run's history files, once the delete of its row has committed. Best effort, as
+     *  deletion always was. */
+    private removeOwedHistory;
+    /**
+     * Count-based history retention: of the runs past the newest `MAX_RUNS_KEPT` unarchived ones,
+     * archive each finished run without delegation that is not pinned and whose family this store
+     * can claim. Ranked over the row keys (the `created_at` index, no record decoded) with memory
+     * laid over them, since a run created or archived since the last save has no row yet; the rows
+     * past the cut are then filtered in `runs.db`, so only real candidates decode. Archived runs
+     * are never deleted by retention — only an explicit delete, worker destruction, or history
+     * deletion removes a run.
+     */
+    private pruneOldRuns;
+    /** Debounced so token-usage updates don't rewrite a row per event. Nothing to schedule without
+     *  a database: a `RunStore.unavailable` store, or a closed one, writes nothing. */
+    private scheduleSave;
+    /** The single database write, so a test can fail it the way a full disk would. */
+    private writeIndex;
+    /**
+     * Write `staged` plus everything still pending — dirty rows from memory, deletions — in one
+     * transaction, then clear the pending marks. Throws with nothing cleared when it fails.
+     * Never copies or sorts the whole store: the cost is the rows that changed.
+     *
+     * Fenced (#779, plan step 3): the transaction commits only if every family it writes still
+     * carries this store's claim and every row is at the revision this store last saw. Otherwise
+     * nothing is written and `handleConflicts` deals with the rows that changed under it.
+     */
+    private persist;
+    /** What a write of these rows (id → family) must still find: this store's claims, at the
+     *  generations it took them, and each row at the revision it last saw (none for a new row). */
+    private fence;
+    /**
+     * 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. */
+    private saveNow;
+    /**
+     * Write what is pending and release the database (store disposal, process shutdown).
+     * Idempotent. A closed store keeps answering reads for what it holds — the final save evicts
+     * nothing — but cannot read `runs.db` any more, so a run that had already left memory reads as
+     * absent. It saves nothing more, and a durable commit on it throws.
+     */
+    close(): void;
+}
+export interface ArchiveOnMergeSnapshot {
+    rootId: string;
+    fingerprint: string;
+    pullRequests: ArchivePullRequestIdentity[];
+    token: string;
+}