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

package/dist/contract/delegation.d.ts

@@ -0,0 +1,2168 @@
+import { z } from 'zod';
+/** Owned workers (spec 2026-09-06). No import from runs: runs embeds this metadata. */
+export declare const workerOperationSchema: z.ZodEnum<{
+    destroy: "destroy";
+    diff: "diff";
+    inspect: "inspect";
+    spawn: "spawn";
+    steer: "steer";
+    stop: "stop";
+    wait: "wait";
+}>;
+export type WorkerOperation = z.infer<typeof workerOperationSchema>;
+/** 1–32 unique ids; the worker wait entry and `cezar_wait` reuse it for worker and request ids. */
+export declare const workerIdsSchema: z.ZodArray<z.ZodUUID>;
+export declare const workerWorkspaceSchema: 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>;
+export type WorkerWorkspace = z.infer<typeof workerWorkspaceSchema>;
+export declare const workerOutcomeSchema: 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>;
+export type WorkerOutcome = z.infer<typeof workerOutcomeSchema>;
+export declare const workerWaitModeSchema: z.ZodEnum<{
+    all: "all";
+    any: "any";
+    one: "one";
+}>;
+export declare const workerWaitSchema: 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>;
+export type WorkerWait = z.infer<typeof workerWaitSchema>;
+/** Cezar's completion wait as inspection and the relationships view show it: the `WorkerWait`
+ *  projection without a deadline, which that wait does not have, and the `via` that names it.
+ *  `WorkerWait` keeps requiring a deadline (hearsay-tools/cezarion#1301). */
+export declare const workerCompletionWaitSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    workerIds: z.ZodArray<z.ZodUUID>;
+    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>;
+    via: z.ZodLiteral<"completion">;
+}, z.core.$strict>;
+export type WorkerCompletionWait = z.infer<typeof workerCompletionWaitSchema>;
+/** Automatic retries of a pending destroy (hearsay-tools/cezarion#879): how many scheduled
+ * attempts ran since the last explicit request, when the next one is due, and whether they
+ * reached the hourly cap with nothing changing, which the cockpit shows as needing attention.
+ * Absent until the first automatic attempt; a manual destroy clears it. Stored on the run record
+ * (`destroyRetry`), never inside the strict worker delegation, so an older cezar strips it instead
+ * of quarantining the worker; the API shows it as the worker's `destroy.retry`. */
+export declare const workerDestroyRetrySchema: z.ZodObject<{
+    attempts: z.ZodNumber;
+    nextAt: z.ZodISODateTime;
+    needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type WorkerDestroyRetry = z.infer<typeof workerDestroyRetrySchema>;
+export declare const workerDestroySchema: 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>;
+export type WorkerDestroy = z.infer<typeof workerDestroySchema>;
+/** A worker's destroy as inspection and relationships show it: the stored phase, plus its retry state. */
+export declare const workerDestroyViewSchema: 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>;
+    retry: z.ZodOptional<z.ZodObject<{
+        attempts: z.ZodNumber;
+        nextAt: z.ZodISODateTime;
+        needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WorkerDestroyView = z.infer<typeof workerDestroyViewSchema>;
+export declare const workerCreationReceiptSchema: 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>;
+export declare const workerBackendSchema: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    cursor: "cursor";
+    omp: "omp";
+    opencode: "opencode";
+    pi: "pi";
+}>;
+/**
+ * Why a `parent-file` path may never be attached, or undefined. An attached `.gitignore` would
+ * rewrite the worker worktree's ignore rules and could re-include another attachment, which its
+ * diff and autosave would then carry (hearsay-tools/cezarion#1149). The schema and the server share it.
+ */
+export declare function parentFileRefusal(path: string): string | undefined;
+export declare const workerContextReferenceSchema: 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">;
+export type WorkerContextReference = z.infer<typeof workerContextReferenceSchema>;
+export declare const workerContextSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodOptional<z.ZodArray<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">>>;
+}, z.core.$strict>;
+export declare const workerInputSchema: 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>;
+export type WorkerInput = z.infer<typeof workerInputSchema>;
+export declare const workerInputRecipeSchema: 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>;
+export type WorkerInputRecipe = z.infer<typeof workerInputRecipeSchema>;
+export declare const workerCollectedResultSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    parentRunId: z.ZodUUID;
+    revision: z.ZodNumber;
+    observedAt: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        queued: "queued";
+        review: "review";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        destroyed: "destroyed";
+        failed: "failed";
+        "review-ready": "review-ready";
+        running: "running";
+    }>;
+    lastExecutionOutcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        "review-ready": "review-ready";
+        running: "running";
+    }>;
+    partial: z.ZodBoolean;
+    settled: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        cursor: "cursor";
+        omp: "omp";
+        opencode: "opencode";
+        pi: "pi";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    baselineSha: z.ZodString;
+    workspace: z.ZodObject<{
+        ownerRunId: z.ZodUUID;
+        resourceId: z.ZodUUID;
+        kind: z.ZodLiteral<"owned-isolated">;
+        path: z.ZodString;
+        branch: z.ZodString;
+        baselineSha: z.ZodString;
+        state: z.ZodOptional<z.ZodEnum<{
+            available: "available";
+            deleted: "deleted";
+            unavailable: "unavailable";
+        }>>;
+    }, z.core.$strict>;
+    cleanup: z.ZodEnum<{
+        cleaning: "cleaning";
+        complete: "complete";
+        incomplete: "incomplete";
+        requested: "requested";
+        retained: "retained";
+        terminating: "terminating";
+    }>;
+    summary: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"available">;
+        text: z.ZodString;
+        source: z.ZodLiteral<"assistant">;
+        seq: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            missing: "missing";
+            "no-assistant-output": "no-assistant-output";
+            unreadable: "unreadable";
+            unverified: "unverified";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"deleted">;
+        reason: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "state">;
+    head: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"available">;
+        sha: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            missing: "missing";
+            "no-assistant-output": "no-assistant-output";
+            unreadable: "unreadable";
+            unverified: "unverified";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+        sha: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"deleted">;
+        reason: z.ZodLiteral<"missing">;
+        sha: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "state">;
+    diff: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"available">;
+        snapshotId: z.ZodUUID;
+        path: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            missing: "missing";
+            "no-assistant-output": "no-assistant-output";
+            unreadable: "unreadable";
+            unverified: "unverified";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"deleted">;
+        reason: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "state">;
+    artifacts: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"available">;
+        items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"available">;
+            id: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                missing: "missing";
+                "no-assistant-output": "no-assistant-output";
+                unreadable: "unreadable";
+                unverified: "unverified";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"deleted">;
+            reason: z.ZodLiteral<"missing">;
+            id: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>], "state">>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            missing: "missing";
+            "no-assistant-output": "no-assistant-output";
+            unreadable: "unreadable";
+            unverified: "unverified";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"deleted">;
+        reason: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "state">;
+}, z.core.$strict>;
+export type WorkerCollectedResult = z.infer<typeof workerCollectedResultSchema>;
+export declare const workerResultFileSchema: z.ZodObject<{
+    result: z.ZodObject<{
+        workerId: z.ZodUUID;
+        parentRunId: z.ZodUUID;
+        revision: z.ZodNumber;
+        observedAt: z.ZodISODateTime;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            queued: "queued";
+            review: "review";
+            running: "running";
+            waiting: "waiting";
+        }>;
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            destroyed: "destroyed";
+            failed: "failed";
+            "review-ready": "review-ready";
+            running: "running";
+        }>;
+        lastExecutionOutcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            "review-ready": "review-ready";
+            running: "running";
+        }>;
+        partial: z.ZodBoolean;
+        settled: z.ZodBoolean;
+        error: z.ZodOptional<z.ZodString>;
+        backend: z.ZodOptional<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            cursor: "cursor";
+            omp: "omp";
+            opencode: "opencode";
+            pi: "pi";
+        }>>;
+        model: z.ZodOptional<z.ZodString>;
+        baselineSha: z.ZodString;
+        workspace: z.ZodObject<{
+            ownerRunId: z.ZodUUID;
+            resourceId: z.ZodUUID;
+            kind: z.ZodLiteral<"owned-isolated">;
+            path: z.ZodString;
+            branch: z.ZodString;
+            baselineSha: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                available: "available";
+                deleted: "deleted";
+                unavailable: "unavailable";
+            }>>;
+        }, z.core.$strict>;
+        cleanup: z.ZodEnum<{
+            cleaning: "cleaning";
+            complete: "complete";
+            incomplete: "incomplete";
+            requested: "requested";
+            retained: "retained";
+            terminating: "terminating";
+        }>;
+        summary: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"available">;
+            text: z.ZodString;
+            source: z.ZodLiteral<"assistant">;
+            seq: z.ZodNumber;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                missing: "missing";
+                "no-assistant-output": "no-assistant-output";
+                unreadable: "unreadable";
+                unverified: "unverified";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"deleted">;
+            reason: z.ZodLiteral<"missing">;
+        }, z.core.$strict>], "state">;
+        head: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"available">;
+            sha: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                missing: "missing";
+                "no-assistant-output": "no-assistant-output";
+                unreadable: "unreadable";
+                unverified: "unverified";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+            sha: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"deleted">;
+            reason: z.ZodLiteral<"missing">;
+            sha: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "state">;
+        diff: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"available">;
+            snapshotId: z.ZodUUID;
+            path: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                missing: "missing";
+                "no-assistant-output": "no-assistant-output";
+                unreadable: "unreadable";
+                unverified: "unverified";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"deleted">;
+            reason: z.ZodLiteral<"missing">;
+        }, z.core.$strict>], "state">;
+        artifacts: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"available">;
+            items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                state: z.ZodLiteral<"available">;
+                id: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    missing: "missing";
+                    "no-assistant-output": "no-assistant-output";
+                    unreadable: "unreadable";
+                    unverified: "unverified";
+                }>;
+                detail: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"deleted">;
+                reason: z.ZodLiteral<"missing">;
+                id: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>], "state">>;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                missing: "missing";
+                "no-assistant-output": "no-assistant-output";
+                unreadable: "unreadable";
+                unverified: "unverified";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"deleted">;
+            reason: z.ZodLiteral<"missing">;
+        }, z.core.$strict>], "state">;
+    }, z.core.$strict>;
+    diffSnapshot: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const workerResultReferenceSchema: 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>;
+export declare const delegationStateSchema: 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">;
+export type DelegationState = z.infer<typeof delegationStateSchema>;
+/** Slim list/palette projection. Never copies resource paths, permissions or receipts. */
+export declare const runDelegationSummarySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    role: z.ZodLiteral<"root">;
+    wait: z.ZodOptional<z.ZodObject<{
+        workerIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        phase: z.ZodEnum<{
+            parked: "parked";
+            registered: "registered";
+            "wake-pending": "wake-pending";
+        }>;
+        outcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            workerId: z.ZodUUID;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"worker">;
+    parentRunId: z.ZodUUID;
+    wait: z.ZodOptional<z.ZodObject<{
+        requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        phase: z.ZodEnum<{
+            parked: "parked";
+            registered: "registered";
+            "wake-pending": "wake-pending";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"invalid">;
+}, z.core.$strip>], "role">;
+export type RunDelegationSummary = z.infer<typeof runDelegationSummarySchema>;
+export declare const workerSpawnRequestSchema: z.ZodObject<{
+    task: z.ZodString;
+    baseline: z.ZodString;
+    requestId: z.ZodUUID;
+    context: z.ZodOptional<z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        artifacts: z.ZodOptional<z.ZodArray<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">>>;
+    }, z.core.$strict>>;
+    backend: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        cursor: "cursor";
+        omp: "omp";
+        opencode: "opencode";
+        pi: "pi";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    skill: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkerSpawnRequest = z.infer<typeof workerSpawnRequestSchema>;
+export declare const workerSteerRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>;
+export type WorkerSteerRequest = z.infer<typeof workerSteerRequestSchema>;
+export declare const workerWaitRequestSchema: z.ZodObject<{
+    workerIds: z.ZodArray<z.ZodUUID>;
+    timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        any: "any";
+        one: "one";
+    }>>;
+}, z.core.$strict>;
+export type WorkerWaitRequest = z.infer<typeof workerWaitRequestSchema>;
+export declare const inboxClaimSchema: 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>;
+export type InboxClaim = z.infer<typeof inboxClaimSchema>;
+export declare const agentInputSchema: 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>;
+export type AgentInput = z.infer<typeof agentInputSchema>;
+export declare const workerInspectionSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    parentRunId: z.ZodUUID;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        queued: "queued";
+        review: "review";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    currentStepId: z.ZodOptional<z.ZodString>;
+    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>;
+    backend: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        cursor: "cursor";
+        omp: "omp";
+        opencode: "opencode";
+        pi: "pi";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodOptional<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>>>;
+    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>>;
+    completionWait: z.ZodOptional<z.ZodObject<{
+        id: z.ZodUUID;
+        workerIds: z.ZodArray<z.ZodUUID>;
+        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>;
+        via: z.ZodLiteral<"completion">;
+    }, 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>;
+        retry: z.ZodOptional<z.ZodObject<{
+            attempts: z.ZodNumber;
+            nextAt: z.ZodISODateTime;
+            needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    outcome: z.ZodOptional<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>>;
+}, z.core.$strip>;
+export type WorkerInspection = z.infer<typeof workerInspectionSchema>;
+/** Small summaries omit inspection inputs, wait payloads and assistant output. */
+export declare const workerListEntrySchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    parentRunId: z.ZodUUID;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        queued: "queued";
+        review: "review";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    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>;
+        retry: z.ZodOptional<z.ZodObject<{
+            attempts: z.ZodNumber;
+            nextAt: z.ZodISODateTime;
+            needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    revision: z.ZodNumber;
+    settled: z.ZodBoolean;
+    destroyed: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const workerListResultSchema: z.ZodObject<{
+    workers: z.ZodArray<z.ZodObject<{
+        workerId: z.ZodUUID;
+        parentRunId: z.ZodUUID;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            queued: "queued";
+            review: "review";
+            running: "running";
+            waiting: "waiting";
+        }>;
+        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>;
+            retry: z.ZodOptional<z.ZodObject<{
+                attempts: z.ZodNumber;
+                nextAt: z.ZodISODateTime;
+                needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        revision: z.ZodNumber;
+        settled: z.ZodBoolean;
+        destroyed: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WorkerListResult = z.infer<typeof workerListResultSchema>;
+/** Receipt offsets are scoped to the authenticated parent; each page examines at most 32. */
+export declare const workerListQuerySchema: z.ZodObject<{
+    offset: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkerListQuery = z.infer<typeof workerListQuerySchema>;
+export declare const workerListPageSchema: z.ZodObject<{
+    workers: z.ZodArray<z.ZodObject<{
+        workerId: z.ZodUUID;
+        parentRunId: z.ZodUUID;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            queued: "queued";
+            review: "review";
+            running: "running";
+            waiting: "waiting";
+        }>;
+        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>;
+            retry: z.ZodOptional<z.ZodObject<{
+                attempts: z.ZodNumber;
+                nextAt: z.ZodISODateTime;
+                needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        revision: z.ZodNumber;
+        settled: z.ZodBoolean;
+        destroyed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    nextOffset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type WorkerListPage = z.infer<typeof workerListPageSchema>;
+export declare const workerDiffSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    baselineSha: z.ZodString;
+    diff: z.ZodString;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+export type WorkerDiff = z.infer<typeof workerDiffSchema>;
+export declare const workerStopResultSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    state: z.ZodEnum<{
+        stopping: "stopping";
+        terminated: "terminated";
+    }>;
+}, z.core.$strip>;
+export type WorkerStopResult = z.infer<typeof workerStopResultSchema>;
+export declare const workerDestroyResultSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    state: z.ZodEnum<{
+        complete: "complete";
+        incomplete: "incomplete";
+    }>;
+    deleted: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"worktree">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"branch">;
+        ref: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
+    remaining: z.ZodArray<z.ZodEnum<{
+        branch: "branch";
+        process: "process";
+        worktree: "worktree";
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkerDestroyResult = z.infer<typeof workerDestroyResultSchema>;
+/** #816: outstanding allocations against `limit`, lifetime creations against `creationLimit`. */
+export declare const workerCapacitySchema: z.ZodObject<{
+    outstanding: z.ZodNumber;
+    limit: z.ZodNumber;
+    created: z.ZodNumber;
+    creationLimit: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkerCapacity = z.infer<typeof workerCapacitySchema>;
+/** A related run's display title: the three fields `runTitle` reads (#864). The cockpit's run list
+ *  carries only the newest archived runs, so the relationships answer names its own runs. */
+export declare const relatedRunTitleSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    titleSummary: z.ZodOptional<z.ZodString>;
+    titleOrigin: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        marker: "marker";
+        user: "user";
+    }>>;
+}, z.core.$strip>;
+export type RelatedRunTitle = z.infer<typeof relatedRunTitleSchema>;
+export declare const runRelationshipsSchema: z.ZodObject<{
+    parentRunId: z.ZodOptional<z.ZodUUID>;
+    workers: z.ZodArray<z.ZodObject<{
+        workerId: z.ZodUUID;
+        parentRunId: z.ZodUUID;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            queued: "queued";
+            review: "review";
+            running: "running";
+            waiting: "waiting";
+        }>;
+        currentStepId: z.ZodOptional<z.ZodString>;
+        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>;
+        backend: z.ZodOptional<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            cursor: "cursor";
+            omp: "omp";
+            opencode: "opencode";
+            pi: "pi";
+        }>>;
+        model: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<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>>>;
+        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>>;
+        completionWait: z.ZodOptional<z.ZodObject<{
+            id: z.ZodUUID;
+            workerIds: z.ZodArray<z.ZodUUID>;
+            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>;
+            via: z.ZodLiteral<"completion">;
+        }, 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>;
+            retry: z.ZodOptional<z.ZodObject<{
+                attempts: z.ZodNumber;
+                nextAt: z.ZodISODateTime;
+                needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        outcome: z.ZodOptional<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>>;
+    }, z.core.$strip>>;
+    titles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        titleSummary: z.ZodOptional<z.ZodString>;
+        titleOrigin: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            marker: "marker";
+            user: "user";
+        }>>;
+    }, z.core.$strip>>>;
+    capacity: z.ZodOptional<z.ZodObject<{
+        outstanding: z.ZodNumber;
+        limit: z.ZodNumber;
+        created: z.ZodNumber;
+        creationLimit: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type RunRelationships = z.infer<typeof runRelationshipsSchema>;
+export declare const delegationErrorResponseSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        capacity_limit: "capacity_limit";
+        denied_scope: "denied_scope";
+        incompatible_state: "incompatible_state";
+        incomplete_cleanup: "incomplete_cleanup";
+        invalid_baseline: "invalid_baseline";
+        invalid_input: "invalid_input";
+        unauthenticated: "unauthenticated";
+        unavailable_diff: "unavailable_diff";
+        unavailable_transport: "unavailable_transport";
+    }>;
+    error: z.ZodString;
+    modelChoices: z.ZodOptional<z.ZodObject<{
+        runner: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            cursor: "cursor";
+            omp: "omp";
+            opencode: "opencode";
+            pi: "pi";
+        }>;
+        requestedModel: z.ZodString;
+        availableModels: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodString;
+            effortLevels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                xhigh: "xhigh";
+            }>>>;
+        }, z.core.$strip>>;
+        otherRunners: z.ZodArray<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            cursor: "cursor";
+            omp: "omp";
+            opencode: "opencode";
+            pi: "pi";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DelegationErrorResponse = z.infer<typeof delegationErrorResponseSchema>;
+export declare const workerParamsSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+}, z.core.$strict>;
+export type WorkerParams = z.infer<typeof workerParamsSchema>;
+export declare const workerSpawnResultSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    baselineSha: z.ZodString;
+}, z.core.$strict>;
+export type WorkerSpawnResult = z.infer<typeof workerSpawnResultSchema>;
+export declare const workerSteerResultSchema: z.ZodObject<{
+    workerId: z.ZodUUID;
+    state: z.ZodEnum<{
+        delivered: "delivered";
+        queued: "queued";
+    }>;
+}, z.core.$strict>;
+export type WorkerSteerResult = z.infer<typeof workerSteerResultSchema>;
+export declare const workerWaitResultSchema: z.ZodObject<{
+    wait: 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>;
+    instruction: z.ZodString;
+}, z.core.$strict>;
+export type WorkerWaitResult = z.infer<typeof workerWaitResultSchema>;
+export declare const workerEmptyRequestSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const workerCancelWaitRequestSchema: z.ZodObject<{
+    waitId: z.ZodUUID;
+}, z.core.$strict>;
+export type WorkerCancelWaitRequest = z.infer<typeof workerCancelWaitRequestSchema>;
+export declare const workerCancelWaitResultSchema: z.ZodObject<{
+    wait: 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>;
+}, z.core.$strict>;
+export type WorkerCancelWaitResult = z.infer<typeof workerCancelWaitResultSchema>;
+/**
+ * `cez message wait --peer` (hearsay-tools/cezarion#1995): a root task waits on 1–32 named peer
+ * root tasks, with a deadline of 1–1,800 s (default 600). The wait answers as its list entry does:
+ * its phase, and once it resolved, why and from which peer.
+ */
+export declare const peerWaitRequestSchema: z.ZodObject<{
+    peerIds: z.ZodArray<z.ZodUUID>;
+    timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type PeerWaitRequest = z.infer<typeof peerWaitRequestSchema>;
+/**
+ * Why a peer wait resolved: a message of any kind from a named peer, with both ids; a named peer that
+ * settled (`review`, `done`, `failed`, `cancelled`) or was deleted, with its id; or the deadline.
+ */
+export declare const peerWaitResultSchema: 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">;
+export type PeerWaitResult = z.infer<typeof peerWaitResultSchema>;
+/** A resolved or delivered peer wait carries its result, an open one none; a cancelled one keeps
+ *  the result it had, if it had one. The entry and its CLI view share the rule. */
+export declare function refinePeerWaitResult(wait: {
+    phase: string;
+    result?: PeerWaitResult | undefined;
+}, ctx: z.RefinementCtx): void;
+export declare const peerWaitViewSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    peerIds: z.ZodArray<z.ZodUUID>;
+    deadline: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        delivered: "delivered";
+        open: "open";
+        resolved: "resolved";
+    }>;
+    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>;
+export type PeerWaitView = z.infer<typeof peerWaitViewSchema>;
+export declare const peerWaitRegisteredSchema: z.ZodObject<{
+    wait: z.ZodObject<{
+        id: z.ZodUUID;
+        peerIds: z.ZodArray<z.ZodUUID>;
+        deadline: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        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>;
+    instruction: z.ZodString;
+}, z.core.$strict>;
+export declare const peerCancelWaitResultSchema: z.ZodObject<{
+    wait: z.ZodObject<{
+        id: z.ZodUUID;
+        peerIds: z.ZodArray<z.ZodUUID>;
+        deadline: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        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.core.$strict>;
+/** What `POST /delegation/wait` and `/cancel-wait` answer: a worker or request wait, or a peer wait. */
+export declare const delegationWaitResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    wait: 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>;
+    instruction: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    wait: z.ZodObject<{
+        id: z.ZodUUID;
+        peerIds: z.ZodArray<z.ZodUUID>;
+        deadline: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        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>;
+    instruction: z.ZodString;
+}, z.core.$strict>]>;
+export declare const delegationCancelWaitResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    wait: 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>;
+}, z.core.$strict>, z.ZodObject<{
+    wait: z.ZodObject<{
+        id: z.ZodUUID;
+        peerIds: z.ZodArray<z.ZodUUID>;
+        deadline: z.ZodISODateTime;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            delivered: "delivered";
+            open: "open";
+            resolved: "resolved";
+        }>;
+        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.core.$strict>]>;