@wjarka/cezarion 0.16.0 → 0.17.0

package/dist/contract/waits.d.ts

@@ -0,0 +1,1204 @@
+import { z } from 'zod';
+import type { DelegationState, RunDelegationSummary, WorkerCompletionWait, WorkerWait } from './delegation.ts';
+import type { RunRecord } from './runs.ts';
+/**
+ * The wait list (spec `.ai/specs/2026-10-17-unified-waits.md`; phase 1 is
+ * hearsay-tools/cezarion#1233). A run holds its open and recently settled waits in
+ * `RunRecord.waits`; the agent opens one with `cezar_wait` and closes it with
+ * `cezar_cancel_wait`. A wait ends only when its own event fires, its deadline passes, or someone
+ * cancels it. Phase 1 carries the `ci` and `timer` kinds; phase 2 (hearsay-tools/cezarion#1234)
+ * adds `human`, which the agent opens with `cezar_ask` and which has no deadline: it ends when
+ * the user answers or the agent cancels it.
+ * Phase 3a (hearsay-tools/cezarion#1235) adds `worker`, which waits on workers' outcomes or on
+ * replies to requests and has a deadline. Phase 3b (hearsay-tools/cezarion#1301) moves the
+ * completion gate's own wait into the list as a `source: 'cezar'`, `via: 'completion'` worker
+ * entry with no deadline, so the list is all `computeWaitingOn` reads.
+ */
+export declare const WAIT_LIMIT = 16;
+export declare const LAST_WAITS_LIMIT = 16;
+export declare const TIMER_MIN_SECONDS = 60;
+export declare const TIMER_MAX_SECONDS = 7200;
+/** A process wait's bounds (hearsay-tools/cezarion#1446): the CI wait's timeout range. */
+export declare const PROCESS_TIMEOUT_DEFAULT_SECONDS = 1800;
+export declare const PROCESS_TIMEOUT_MAX_SECONDS = 7200;
+export declare const PROCESS_EXIT_FILE_MAX = 4096;
+/** `open` → `resolved` (its event fired or its deadline passed) → `delivered`, or `cancelled`. */
+export declare const waitPhaseSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    delivered: "delivered";
+    open: "open";
+    resolved: "resolved";
+}>;
+export type WaitPhase = z.infer<typeof waitPhaseSchema>;
+/** What opened the wait: the tool itself, or one of the aliases that map into the same list.
+ *  `no-wait` is the human wait cezar opens when a nudged turn still ends without one; `budget`
+ *  is the one it opens when the automatic-wake budget is spent; `cez-worker-wait` is
+ *  `cez worker wait`, the alias that opens a `worker` wait; `completion` is the worker wait
+ *  cezar opens for a root whose done is refused twice (hearsay-tools/cezarion#1301). */
+export declare const waitViaSchema: z.ZodEnum<{
+    "ask-line": "ask-line";
+    budget: "budget";
+    "cez-worker-wait": "cez-worker-wait";
+    cezar_ask: "cezar_ask";
+    cezar_wait: "cezar_wait";
+    cezar_wait_for_ci: "cezar_wait_for_ci";
+    completion: "completion";
+    "monitoring-line": "monitoring-line";
+    "native-ask": "native-ask";
+    "no-wait": "no-wait";
+    "schedule-wakeup": "schedule-wakeup";
+}>;
+export type WaitVia = z.infer<typeof waitViaSchema>;
+/** A pull request's checks or its merge (hearsay-tools/cezarion#1425; kind `ci` before it, which
+ *  the store reads as `until: 'checks'`, `wakeOnConflict: true`). */
+export declare const prWaitEntrySchema: z.ZodObject<{
+    prUrl: z.ZodString;
+    repository: z.ZodString;
+    prNumber: z.ZodNumber;
+    headSha: z.ZodString;
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"pr">;
+    deadline: z.ZodISODateTime;
+    generation: z.ZodString;
+    timeoutSeconds: z.ZodNumber;
+    until: z.ZodEnum<{
+        checks: "checks";
+        merge: "merge";
+    }>;
+    wakeOnConflict: z.ZodBoolean;
+    result: z.ZodOptional<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            closed: "closed";
+            conflicting: "conflicting";
+            deadline: "deadline";
+            error: "error";
+            failed: "failed";
+            head_changed: "head_changed";
+            merged: "merged";
+            no_checks: "no_checks";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        headSha: z.ZodString;
+        observedHeadSha: z.ZodOptional<z.ZodString>;
+        mergeable: z.ZodOptional<z.ZodEnum<{
+            CONFLICTING: "CONFLICTING";
+            MERGEABLE: "MERGEABLE";
+            UNKNOWN: "UNKNOWN";
+        }>>;
+        mergeStateStatus: z.ZodOptional<z.ZodString>;
+        mergedAt: z.ZodOptional<z.ZodISODateTime>;
+        mergeCommitSha: z.ZodOptional<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+        checks: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            state: z.ZodString;
+            link: z.ZodString;
+        }, z.core.$strict>>;
+        totalChecks: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        diagnostic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PrWaitEntry = z.infer<typeof prWaitEntrySchema>;
+export declare const timerWaitEntrySchema: z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"timer">;
+    deadline: z.ZodISODateTime;
+    seconds: z.ZodNumber;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TimerWaitEntry = z.infer<typeof timerWaitEntrySchema>;
+/**
+ * How a process wait ended (hearsay-tools/cezarion#1446): the exit file appeared (`exitCode` when
+ * its first line is an integer, else `exitFileNote`), the process is gone with no exit file
+ * (`exited`, code unknown), it still ran at the deadline, or the check failed (`error`).
+ */
+export declare const processWaitResultSchema: 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>;
+export type ProcessWaitResult = z.infer<typeof processWaitResultSchema>;
+/**
+ * A command the agent started in the background, watched by its PID (hearsay-tools/cezarion#1446).
+ * `startToken` pins the process incarnation, so a reused PID never matches; it is absent when the
+ * PID was already gone at registration or the platform cannot say. `exitFile` is the resolved
+ * absolute path the command writes its exit code to.
+ */
+export declare const processWaitEntrySchema: z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"process">;
+    deadline: z.ZodISODateTime;
+    timeoutSeconds: z.ZodNumber;
+    pid: z.ZodNumber;
+    startToken: z.ZodOptional<z.ZodString>;
+    exitFile: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            deadline: "deadline";
+            error: "error";
+            exit_file: "exit_file";
+            exited: "exited";
+        }>;
+        observedAt: z.ZodISODateTime;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        exitFileNote: z.ZodOptional<z.ZodLiteral<"not-an-exit-code">>;
+        diagnostic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProcessWaitEntry = z.infer<typeof processWaitEntrySchema>;
+/** The user. `questions` is the card the agent asked with, absent for a plain "your turn";
+ *  `askSeq` is the event cezar showed it as, once the turn ended: its `ask.requested`, the human
+ *  gate a wait without a card raises, or the note that shows Cezar's own wait. */
+export declare const humanWaitEntrySchema: z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"human">;
+    questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        header: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        multiSelect: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    context: z.ZodOptional<z.ZodString>;
+    askSeq: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type HumanWaitEntry = z.infer<typeof humanWaitEntrySchema>;
+/**
+ * Workers' outcomes, or replies to requests the run sent (hearsay-tools/cezarion#1235). The
+ * target is exactly one of `workerIds` (with `revisions` and `outcomes`) and `requestIds` (with
+ * `requestOutcomes`); every outcome is the first observation, durable once recorded. Unlike a
+ * CI wait it has no `generation`: a worker's identity is its id. `result.reason` is why it
+ * resolved; `cancelled` is a phase, and a message no longer ends a wait.
+ * `wakeInputId` is an upgraded row's already-queued wake input, delivered once instead of the
+ * list's `input.id === wait.id` convention.
+ */
+export declare const workerWaitEntrySchema: z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"worker">;
+    deadline: z.ZodOptional<z.ZodISODateTime>;
+    timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        any: "any";
+        one: "one";
+    }>>;
+    workerIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    revisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        workerId: z.ZodUUID;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>>;
+    outcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        workerId: z.ZodUUID;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            review: "review";
+        }>;
+        observedAt: z.ZodISODateTime;
+        summary: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        requestId: z.ZodUUID;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            "completed-without-reply": "completed-without-reply";
+            destroyed: "destroyed";
+            failed: "failed";
+            "human-fallback": "human-fallback";
+            replied: "replied";
+            "replied-late": "replied-late";
+            "sender-closed": "sender-closed";
+            "timed-out": "timed-out";
+        }>;
+        observedAt: z.ZodISODateTime;
+        replyId: z.ZodOptional<z.ZodUUID>;
+    }, z.core.$strict>>>;
+    result: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<{
+            outcome: "outcome";
+            timeout: "timeout";
+        }>;
+    }, z.core.$strict>>;
+    wakeInputId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>;
+export type WorkerWaitEntry = z.infer<typeof workerWaitEntrySchema>;
+/** An entry the legacy `WorkerWait` shape can render: its deadline is required there. Cezar's
+ *  deadline-less completion wait is not one (hearsay-tools/cezarion#1301). */
+export type DeadlinedWorkerWaitEntry = WorkerWaitEntry & {
+    deadline: string;
+};
+export declare const hasWorkerDeadline: (entry: WorkerWaitEntry) => entry is DeadlinedWorkerWaitEntry;
+export declare const waitSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    prUrl: z.ZodString;
+    repository: z.ZodString;
+    prNumber: z.ZodNumber;
+    headSha: z.ZodString;
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"pr">;
+    deadline: z.ZodISODateTime;
+    generation: z.ZodString;
+    timeoutSeconds: z.ZodNumber;
+    until: z.ZodEnum<{
+        checks: "checks";
+        merge: "merge";
+    }>;
+    wakeOnConflict: z.ZodBoolean;
+    result: z.ZodOptional<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            closed: "closed";
+            conflicting: "conflicting";
+            deadline: "deadline";
+            error: "error";
+            failed: "failed";
+            head_changed: "head_changed";
+            merged: "merged";
+            no_checks: "no_checks";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        headSha: z.ZodString;
+        observedHeadSha: z.ZodOptional<z.ZodString>;
+        mergeable: z.ZodOptional<z.ZodEnum<{
+            CONFLICTING: "CONFLICTING";
+            MERGEABLE: "MERGEABLE";
+            UNKNOWN: "UNKNOWN";
+        }>>;
+        mergeStateStatus: z.ZodOptional<z.ZodString>;
+        mergedAt: z.ZodOptional<z.ZodISODateTime>;
+        mergeCommitSha: z.ZodOptional<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+        checks: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            state: z.ZodString;
+            link: z.ZodString;
+        }, z.core.$strict>>;
+        totalChecks: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        diagnostic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"timer">;
+    deadline: z.ZodISODateTime;
+    seconds: z.ZodNumber;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"human">;
+    questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        header: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        multiSelect: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    context: z.ZodOptional<z.ZodString>;
+    askSeq: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"worker">;
+    deadline: z.ZodOptional<z.ZodISODateTime>;
+    timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        any: "any";
+        one: "one";
+    }>>;
+    workerIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    revisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        workerId: z.ZodUUID;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>>;
+    outcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        workerId: z.ZodUUID;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            review: "review";
+        }>;
+        observedAt: z.ZodISODateTime;
+        summary: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        requestId: z.ZodUUID;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            "completed-without-reply": "completed-without-reply";
+            destroyed: "destroyed";
+            failed: "failed";
+            "human-fallback": "human-fallback";
+            replied: "replied";
+            "replied-late": "replied-late";
+            "sender-closed": "sender-closed";
+            "timed-out": "timed-out";
+        }>;
+        observedAt: z.ZodISODateTime;
+        replyId: z.ZodOptional<z.ZodUUID>;
+    }, z.core.$strict>>>;
+    result: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<{
+            outcome: "outcome";
+            timeout: "timeout";
+        }>;
+    }, z.core.$strict>>;
+    wakeInputId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodEnum<{
+        agent: "agent";
+        cezar: "cezar";
+    }>;
+    via: z.ZodEnum<{
+        "ask-line": "ask-line";
+        budget: "budget";
+        "cez-worker-wait": "cez-worker-wait";
+        cezar_ask: "cezar_ask";
+        cezar_wait: "cezar_wait";
+        cezar_wait_for_ci: "cezar_wait_for_ci";
+        completion: "completion";
+        "monitoring-line": "monitoring-line";
+        "native-ask": "native-ask";
+        "no-wait": "no-wait";
+        "schedule-wakeup": "schedule-wakeup";
+    }>;
+    registeredAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    resolvedAt: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    turnId: z.ZodString;
+    kind: z.ZodLiteral<"process">;
+    deadline: z.ZodISODateTime;
+    timeoutSeconds: z.ZodNumber;
+    pid: z.ZodNumber;
+    startToken: z.ZodOptional<z.ZodString>;
+    exitFile: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            deadline: "deadline";
+            error: "error";
+            exit_file: "exit_file";
+            exited: "exited";
+        }>;
+        observedAt: z.ZodISODateTime;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        exitFileNote: z.ZodOptional<z.ZodLiteral<"not-an-exit-code">>;
+        diagnostic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+export type Wait = z.infer<typeof waitSchema>;
+/** `cezar_wait`. The `pr` branch keeps the removed `cezar_wait_for_ci`'s bounds and default;
+ *  it replaced kind `ci` (hearsay-tools/cezarion#1425). */
+export declare const cezarWaitRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    pr: z.ZodString;
+    until: z.ZodDefault<z.ZodEnum<{
+        checks: "checks";
+        merge: "merge";
+    }>>;
+    wake_on_conflict: z.ZodDefault<z.ZodBoolean>;
+    timeout_seconds: z.ZodDefault<z.ZodNumber>;
+    kind: z.ZodLiteral<"pr">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worker">;
+    worker_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    request_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        any: "any";
+        one: "one";
+    }>>;
+    timeout_seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"timer">;
+    seconds: z.ZodNumber;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"process">;
+    pid: z.ZodNumber;
+    exit_file: z.ZodOptional<z.ZodString>;
+    timeout_seconds: z.ZodDefault<z.ZodNumber>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type CezarWaitRequest = z.infer<typeof cezarWaitRequestSchema>;
+/** What a caller may send: the defaults (`until`, `wake_on_conflict`, `timeout_seconds`) still unset. */
+export type CezarWaitRequestInput = z.input<typeof cezarWaitRequestSchema>;
+export declare const cezarCancelWaitRequestSchema: z.ZodObject<{
+    wait_id: z.ZodUUID;
+}, z.core.$strict>;
+export type CezarCancelWaitRequest = z.infer<typeof cezarCancelWaitRequestSchema>;
+export declare const openWaitSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    wait_id: z.ZodUUID;
+    summary: z.ZodString;
+    kind: z.ZodEnum<{
+        pr: "pr";
+        process: "process";
+        timer: "timer";
+        worker: "worker";
+    }>;
+    deadline: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    wait_id: z.ZodUUID;
+    summary: z.ZodString;
+    kind: z.ZodLiteral<"human">;
+}, z.core.$strict>], "kind">;
+export type OpenWait = z.infer<typeof openWaitSchema>;
+export declare const waitErrorCodeSchema: z.ZodEnum<{
+    authentication: "authentication";
+    capability_revoked: "capability_revoked";
+    capacity: "capacity";
+    command_failed: "command_failed";
+    denied_scope: "denied_scope";
+    exit_file_outside: "exit_file_outside";
+    finish_requested: "finish_requested";
+    generation_mismatch: "generation_mismatch";
+    gh_missing: "gh_missing";
+    inaccessible_pr: "inaccessible_pr";
+    invalid_request: "invalid_request";
+    malformed_data: "malformed_data";
+    manager_disposed: "manager_disposed";
+    output_limit: "output_limit";
+    persistence: "persistence";
+    process_not_allowed: "process_not_allowed";
+    process_not_owned: "process_not_owned";
+    query_timeout: "query_timeout";
+    registration_aborted: "registration_aborted";
+    root_finish_pending: "root_finish_pending";
+    run_cancelled: "run_cancelled";
+    run_missing: "run_missing";
+    run_not_running: "run_not_running";
+    run_stopping: "run_stopping";
+    session_closed: "session_closed";
+    session_replaced: "session_replaced";
+    timers_disabled: "timers_disabled";
+    turn_changed: "turn_changed";
+    unauthorized: "unauthorized";
+    unavailable: "unavailable";
+    unsupported_host: "unsupported_host";
+    wait_conflict: "wait_conflict";
+    wake_budget_spent: "wake_budget_spent";
+    worker_execution_stopped: "worker_execution_stopped";
+    worker_wait_pending: "worker_wait_pending";
+}>;
+export type WaitErrorCode = z.infer<typeof waitErrorCodeSchema>;
+/** The bound on every wait and done refusal's `message`; the run manager fits its own to it. */
+export declare const WAIT_MESSAGE_MAX = 4096;
+export declare const cezarWaitAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    wait_id: z.ZodUUID;
+    kind: z.ZodEnum<{
+        pr: "pr";
+        process: "process";
+        timer: "timer";
+        worker: "worker";
+    }>;
+    deadline: z.ZodISODateTime;
+    open_waits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodEnum<{
+        authentication: "authentication";
+        capability_revoked: "capability_revoked";
+        capacity: "capacity";
+        command_failed: "command_failed";
+        denied_scope: "denied_scope";
+        exit_file_outside: "exit_file_outside";
+        finish_requested: "finish_requested";
+        generation_mismatch: "generation_mismatch";
+        gh_missing: "gh_missing";
+        inaccessible_pr: "inaccessible_pr";
+        invalid_request: "invalid_request";
+        malformed_data: "malformed_data";
+        manager_disposed: "manager_disposed";
+        output_limit: "output_limit";
+        persistence: "persistence";
+        process_not_allowed: "process_not_allowed";
+        process_not_owned: "process_not_owned";
+        query_timeout: "query_timeout";
+        registration_aborted: "registration_aborted";
+        root_finish_pending: "root_finish_pending";
+        run_cancelled: "run_cancelled";
+        run_missing: "run_missing";
+        run_not_running: "run_not_running";
+        run_stopping: "run_stopping";
+        session_closed: "session_closed";
+        session_replaced: "session_replaced";
+        timers_disabled: "timers_disabled";
+        turn_changed: "turn_changed";
+        unauthorized: "unauthorized";
+        unavailable: "unavailable";
+        unsupported_host: "unsupported_host";
+        wait_conflict: "wait_conflict";
+        wake_budget_spent: "wake_budget_spent";
+        worker_execution_stopped: "worker_execution_stopped";
+        worker_wait_pending: "worker_wait_pending";
+    }>;
+    message: z.ZodString;
+    open_waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>], "ok">;
+export type CezarWaitAnswer = z.infer<typeof cezarWaitAnswerSchema>;
+/**
+ * `cezar_ask` (hearsay-tools/cezarion#1234): the user's answer, asked with a card. A question
+ * without options is open, and the user types its answer. The wait it opens has no deadline.
+ * `context` is required here (hearsay-tools/cezarion#1458), optional in every stored shape.
+ */
+export declare const cezarAskRequestSchema: z.ZodObject<{
+    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>>;
+    context: z.ZodString;
+}, z.core.$strict>;
+export type CezarAskRequest = z.infer<typeof cezarAskRequestSchema>;
+/** The refusals a question can meet: the session's, the run's capacity, and an autonomous run. */
+export declare const askErrorCodeSchema: z.ZodEnum<{
+    autonomous_run: "autonomous_run";
+    capability_revoked: "capability_revoked";
+    capacity: "capacity";
+    finish_requested: "finish_requested";
+    generation_mismatch: "generation_mismatch";
+    invalid_request: "invalid_request";
+    manager_disposed: "manager_disposed";
+    persistence: "persistence";
+    root_finish_pending: "root_finish_pending";
+    run_cancelled: "run_cancelled";
+    run_missing: "run_missing";
+    run_not_running: "run_not_running";
+    run_stopping: "run_stopping";
+    session_closed: "session_closed";
+    session_replaced: "session_replaced";
+    unauthorized: "unauthorized";
+    unavailable: "unavailable";
+    worker_execution_stopped: "worker_execution_stopped";
+    worker_wait_pending: "worker_wait_pending";
+}>;
+export type AskErrorCode = z.infer<typeof askErrorCodeSchema>;
+export declare const cezarAskAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    wait_id: z.ZodUUID;
+    open_waits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodEnum<{
+        autonomous_run: "autonomous_run";
+        capability_revoked: "capability_revoked";
+        capacity: "capacity";
+        finish_requested: "finish_requested";
+        generation_mismatch: "generation_mismatch";
+        invalid_request: "invalid_request";
+        manager_disposed: "manager_disposed";
+        persistence: "persistence";
+        root_finish_pending: "root_finish_pending";
+        run_cancelled: "run_cancelled";
+        run_missing: "run_missing";
+        run_not_running: "run_not_running";
+        run_stopping: "run_stopping";
+        session_closed: "session_closed";
+        session_replaced: "session_replaced";
+        unauthorized: "unauthorized";
+        unavailable: "unavailable";
+        worker_execution_stopped: "worker_execution_stopped";
+        worker_wait_pending: "worker_wait_pending";
+    }>;
+    message: z.ZodString;
+    open_waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>], "ok">;
+export type CezarAskAnswer = z.infer<typeof cezarAskAnswerSchema>;
+/** `already_resolved`: the result is owed and arrives with the next wake; cancelling is a no-op.
+ *  `human_question`: the question already reached the user, so only their answer ends it. */
+export declare const cezarCancelWaitAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    cancelled: z.ZodLiteral<true>;
+    wait_id: z.ZodUUID;
+    open_waits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    cancelled: z.ZodLiteral<false>;
+    code: z.ZodEnum<{
+        already_resolved: "already_resolved";
+        human_question: "human_question";
+        invalid_request: "invalid_request";
+        not_found: "not_found";
+        unavailable: "unavailable";
+    }>;
+    message: z.ZodString;
+    open_waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>], "cancelled">;
+export type CezarCancelWaitAnswer = z.infer<typeof cezarCancelWaitAnswerSchema>;
+/** `cezar_done`: the run finishes when this turn ends. The summary becomes the closing note. */
+export declare const cezarDoneRequestSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CezarDoneRequest = z.infer<typeof cezarDoneRequestSchema>;
+export declare const doneErrorCodeSchema: z.ZodEnum<{
+    capability_revoked: "capability_revoked";
+    finish_requested: "finish_requested";
+    generation_mismatch: "generation_mismatch";
+    human_question_pending: "human_question_pending";
+    invalid_request: "invalid_request";
+    manager_disposed: "manager_disposed";
+    not_final_step: "not_final_step";
+    root_finish_pending: "root_finish_pending";
+    run_cancelled: "run_cancelled";
+    run_missing: "run_missing";
+    run_not_running: "run_not_running";
+    run_stopping: "run_stopping";
+    session_closed: "session_closed";
+    session_replaced: "session_replaced";
+    unavailable: "unavailable";
+    worker_questions: "worker_questions";
+    worker_wait_pending: "worker_wait_pending";
+    workers_outstanding: "workers_outstanding";
+    workers_uncollected: "workers_uncollected";
+}>;
+export type DoneErrorCode = z.infer<typeof doneErrorCodeSchema>;
+/** An accepted done finishes the task, or, in a workflow step that is not the last, completes that
+ *  step and starts `next_step`, named as the run's rail names it (hearsay-tools/cezarion#1620). */
+export declare const cezarDoneAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    finishes: z.ZodLiteral<"at_turn_end">;
+    open_waits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>;
+    completes: z.ZodLiteral<"task">;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    finishes: z.ZodLiteral<"at_turn_end">;
+    open_waits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>;
+    completes: z.ZodLiteral<"step">;
+    next_step: z.ZodString;
+}, z.core.$strict>], "completes">, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodEnum<{
+        capability_revoked: "capability_revoked";
+        finish_requested: "finish_requested";
+        generation_mismatch: "generation_mismatch";
+        human_question_pending: "human_question_pending";
+        invalid_request: "invalid_request";
+        manager_disposed: "manager_disposed";
+        not_final_step: "not_final_step";
+        root_finish_pending: "root_finish_pending";
+        run_cancelled: "run_cancelled";
+        run_missing: "run_missing";
+        run_not_running: "run_not_running";
+        run_stopping: "run_stopping";
+        session_closed: "session_closed";
+        session_replaced: "session_replaced";
+        unavailable: "unavailable";
+        worker_questions: "worker_questions";
+        worker_wait_pending: "worker_wait_pending";
+        workers_outstanding: "workers_outstanding";
+        workers_uncollected: "workers_uncollected";
+    }>;
+    message: z.ZodString;
+    workers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        worker_id: z.ZodString;
+        reason: z.ZodEnum<{
+            outstanding: "outstanding";
+            question: "question";
+            uncollected: "uncollected";
+        }>;
+    }, z.core.$strict>>>;
+    open_waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodEnum<{
+            pr: "pr";
+            process: "process";
+            timer: "timer";
+            worker: "worker";
+        }>;
+        deadline: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        wait_id: z.ZodUUID;
+        summary: z.ZodString;
+        kind: z.ZodLiteral<"human">;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>], "ok">;
+export type CezarDoneAnswer = z.infer<typeof cezarDoneAnswerSchema>;
+/** Stored summaries written before hearsay-tools/cezarion#1425 carry `{ kind: 'ci' }`: a checks wait. */
+export declare const waitingOnSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"human">;
+    shown: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"usage-limit">;
+    at: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"workers">;
+    count: z.ZodNumber;
+    replies: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pr">;
+    until: z.ZodEnum<{
+        checks: "checks";
+        merge: "merge";
+    }>;
+    waitId: z.ZodUUID;
+    prUrl: z.ZodString;
+    repository: z.ZodString;
+    prNumber: z.ZodNumber;
+    deadline: z.ZodISODateTime;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"process">;
+    waitId: z.ZodUUID;
+    pid: z.ZodNumber;
+    deadline: z.ZodISODateTime;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"timer">;
+    waitId: z.ZodUUID;
+    at: z.ZodISODateTime;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">>;
+export type WaitingOn = z.infer<typeof waitingOnSchema>;
+/** Full records carry the full delegation state; summaries and index rows the slim projection. */
+export type WaitingOnInput = Partial<Pick<RunRecord, 'status' | 'waits' | 'autoResumeAt'>> & {
+    delegation?: DelegationState | RunDelegationSummary | undefined;
+};
+/**
+ * A usage-limit hold (hearsay-tools/cezarion#1236): a `waiting` run with a booked resume time. It
+ * holds no slot and no session, so the engine does not own it; its resume or the user's Continue
+ * wakes it. The one definition every reader calls (hearsay-tools/cezarion#1496). It takes the
+ * record, never a bare status, and the store clears the resume time on every write that leaves
+ * `waiting`, so a resume time on any other run is stale and this reads it as no hold. It narrows
+ * the time only, so a caller can still settle the hold to another status.
+ */
+export declare function isUsageLimitHold<T extends Partial<Pick<RunRecord, 'status' | 'autoResumeAt'>>>(run: T): run is T & {
+    autoResumeAt: string;
+};
+/** Reads only `open` waits; among several of one kind the earliest deadline wins. */
+export declare function computeWaitingOn(run: WaitingOnInput): WaitingOn | undefined;
+/** Whether the run waits on the user: an open human wait (phase 4b, hearsay-tools/cezarion#1236). */
+export declare function asksHuman(run: Pick<WaitingOnInput, 'waits'>): boolean;
+/** Whether a question waits on the user: an open human wait the agent opened, or one of Cezar's
+ *  that carries a card (a worker's fallback question to its parent). Cezar's other waits
+ *  (`no-wait`, `budget`, `completion`) wait for the user without a question. */
+export declare function asksQuestion(run: Pick<WaitingOnInput, 'waits'>): boolean;
+/** A resolved wait is a wake owed to the agent: its result is in, its turn has not started.
+ *  Rung 10 of the attention ladder ("waiting for capacity"); a summary carries it as
+ *  `waitWakePending`. */
+export declare function hasResolvedWait(run: {
+    waitWakePending?: true | undefined;
+} & Pick<WaitingOnInput, 'waits'>): boolean;
+/** A summary's `waitingOn` when it has one; a full or stream-patched record computes it. */
+export declare function resolveWaitingOn(run: {
+    waitingOn?: WaitingOn | undefined;
+} & WaitingOnInput): WaitingOn | undefined;
+/**
+ * A run's worker wait in the old `WorkerWait` shape, for views that still show one: the newest
+ * open or owed `worker` entry the agent registered (hearsay-tools/cezarion#1235). Cezar's
+ * completion wait has no deadline, which that shape requires, so it is not one
+ * (hearsay-tools/cezarion#1301). An open entry reads `parked` once the run waits on it, unless a
+ * pending question holds the run.
+ */
+export declare function workerWaitView(run: Partial<Pick<RunRecord, 'status' | 'waits' | 'delegation'>>): WorkerWait | undefined;
+/** The newest open or owed deadline-less completion entry, which `workerWaitView` leaves out. */
+export declare function completionWaitEntry(waits: readonly Wait[] | undefined, workerId?: string): WorkerWaitEntry | undefined;
+/**
+ * Cezar's completion wait as inspection and the relationships view show it, read from the list
+ * like `workerWaitView` (hearsay-tools/cezarion#1301): its phases map as the legacy shape's do.
+ */
+export declare function workerCompletionWaitProjection(entry: WorkerWaitEntry, run: Partial<Pick<RunRecord, 'status' | 'waits'>>): WorkerCompletionWait;
+/** A run's deadline-less completion wait in its projection, for the relationships view. */
+export declare function completionWaitView(run: Partial<Pick<RunRecord, 'status' | 'waits' | 'delegation'>>): WorkerCompletionWait | undefined;
+/**
+ * A worker wait as `cez worker wait` and `cez worker cancel-wait` answer it: the old
+ * `WorkerWait` shape, whose wire stays unchanged (hearsay-tools/cezarion#1235). Open is
+ * `registered`; every settled phase is `wake-pending` and the reason says how it ended.
+ */
+export declare function workerWaitEntryToLegacy(entry: DeadlinedWorkerWaitEntry): WorkerWait;