@wjarka/cezarion 0.16.0 → 0.17.0

package/dist/contract/runs.d.ts

@@ -17,6 +17,31 @@ import { z } from 'zod';
  *    keys. The client narrows on which key is present, and the DTO's flattened shape allowed
  *    `{}` — a payload the route cannot produce.
  */
+/** Canonical GitHub authority retained with an automatic archive receipt. */
+export declare const archivePullRequestIdentitySchema: z.ZodObject<{
+    owner: z.ZodString;
+    repo: z.ZodString;
+    number: z.ZodNumber;
+}, z.core.$strip>;
+export type ArchivePullRequestIdentity = z.infer<typeof archivePullRequestIdentitySchema>;
+export declare const mergedPullRequestSchema: z.ZodObject<{
+    owner: z.ZodString;
+    repo: z.ZodString;
+    number: z.ZodNumber;
+    mergedAt: z.ZodString;
+}, z.core.$strip>;
+export type MergedPullRequest = z.infer<typeof mergedPullRequestSchema>;
+export declare const autoArchiveReceiptSchema: z.ZodObject<{
+    reason: z.ZodLiteral<"pull-requests-merged">;
+    archivedAt: z.ZodString;
+    fingerprint: z.ZodString;
+    pullRequests: z.ZodArray<z.ZodObject<{
+        owner: z.ZodString;
+        repo: z.ZodString;
+        number: z.ZodNumber;
+        mergedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const runStatusSchema: z.ZodEnum<{
     cancelled: "cancelled";
     done: "done";
@@ -27,15 +52,16 @@ export declare const runStatusSchema: z.ZodEnum<{
     waiting: "waiting";
 }>;
 export type RunStatus = z.infer<typeof runStatusSchema>;
-/**
- * Sub-state of `running` (spec 2026-07-18-subagent-monitoring-status, #490): the agent ended its
- * turn still working on its own downstream work (a sub-agent, a monitored command) and said so
- * with the `CEZ:MONITORING` marker — a non-attention state, not "needs you".
- */
-export declare const runActivitySchema: z.ZodEnum<{
-    monitoring: "monitoring";
-}>;
-export type RunActivity = z.infer<typeof runActivitySchema>;
+/** Durable completion work. The id fences replies from a previous completion or setting. */
+export declare const completionActionSchema: z.ZodObject<{
+    id: z.ZodString;
+    phase: z.ZodEnum<{
+        blocked: "blocked";
+        complete: "complete";
+        pending: "pending";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const stepStatusSchema: z.ZodEnum<{
     cancelled: "cancelled";
     done: "done";
@@ -47,6 +73,12 @@ export declare const stepStatusSchema: z.ZodEnum<{
     waiting: "waiting";
 }>;
 export type StepStatus = z.infer<typeof stepStatusSchema>;
+/** Wire transport that owns a Cursor native session. Legacy Cursor sessions omit it (ACP). */
+export declare const sessionTransportSchema: z.ZodEnum<{
+    "cursor-acp": "cursor-acp";
+    "cursor-print": "cursor-print";
+}>;
+export type SessionTransport = z.infer<typeof sessionTransportSchema>;
 /** One step of a run's chain. */
 export declare const stepStateSchema: z.ZodObject<{
     id: z.ZodString;
@@ -79,6 +111,10 @@ export declare const stepStateSchema: z.ZodObject<{
     finishedAt: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
     sessionId: z.ZodOptional<z.ZodString>;
+    sessionTransport: z.ZodOptional<z.ZodEnum<{
+        "cursor-acp": "cursor-acp";
+        "cursor-print": "cursor-print";
+    }>>;
     backend: z.ZodOptional<z.ZodEnum<{
         claude: "claude";
         codex: "codex";
@@ -119,6 +155,13 @@ export declare const continuationMessageSchema: z.ZodObject<{
         lifecycle: "lifecycle";
     }>>;
     agentInputId: z.ZodOptional<z.ZodUUID>;
+    resumeContext: z.ZodOptional<z.ZodObject<{
+        failure: z.ZodOptional<z.ZodObject<{
+            stepId: z.ZodOptional<z.ZodString>;
+            error: z.ZodString;
+        }, z.core.$strip>>;
+        restarted: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /** One aggregated sample of a run's live process tree (`src/core/process-usage.ts`). */
 export declare const processUsageSchema: z.ZodObject<{
@@ -127,11 +170,14 @@ export declare const processUsageSchema: z.ZodObject<{
     procCount: z.ZodNumber;
 }, z.core.$strip>;
 export type ProcessUsage = z.infer<typeof processUsageSchema>;
-/** What the last task-webhook delivery did (#589). A success clears `lastError`; a failure after
- *  every attempt keeps `lastDeliveredAt` from the last one that worked. */
+/** What the last task-webhook delivery did (#589). A failure after every attempt keeps
+ *  `lastDeliveredAt` from the last one that worked. With several webhooks
+ *  (hearsay-tools/cezarion#1576), `lastError` starts with the failed webhook's name and
+ *  `lastErrorWebhookId` names it; only a later success to that webhook clears it. */
 export declare const runWebhookOutcomeSchema: z.ZodObject<{
     lastDeliveredAt: z.ZodOptional<z.ZodString>;
     lastError: z.ZodOptional<z.ZodString>;
+    lastErrorWebhookId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type RunWebhookOutcome = z.infer<typeof runWebhookOutcomeSchema>;
 /**
@@ -158,6 +204,16 @@ export declare const runWorktreeSetupSchema: z.ZodObject<{
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type RunWorktreeSetup = z.infer<typeof runWorktreeSetupSchema>;
+/** Task-owned PR evidence (hearsay-tools/cezarion#922); candidates never enter this list. */
+export declare const runPullRequestSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    url: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+        created: "created";
+        declared: "declared";
+    }>;
+}, z.core.$strip>;
+export type RunPullRequest = z.infer<typeof runPullRequestSchema>;
 export declare const runRecordSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
@@ -187,7 +243,15 @@ export declare const runRecordSchema: z.ZodObject<{
             lifecycle: "lifecycle";
         }>>;
         agentInputId: z.ZodOptional<z.ZodUUID>;
+        resumeContext: z.ZodOptional<z.ZodObject<{
+            failure: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodOptional<z.ZodString>;
+                error: z.ZodString;
+            }, z.core.$strip>>;
+            restarted: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
+    workflowResumeStepId: z.ZodOptional<z.ZodString>;
     invalidAsk: z.ZodOptional<z.ZodBoolean>;
     delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodLiteral<"root">;
@@ -216,14 +280,15 @@ export declare const runRecordSchema: z.ZodObject<{
                 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.ZodArray<z.ZodObject<{
+                        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
                             label: z.ZodString;
                             description: z.ZodOptional<z.ZodString>;
-                        }, z.core.$strict>>;
+                        }, z.core.$strict>>>;
                         multiSelect: z.ZodOptional<z.ZodBoolean>;
                     }, z.core.$strict>>;
                 }, z.core.$strict>>;
@@ -237,6 +302,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -280,6 +346,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -334,6 +401,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -423,6 +491,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -477,6 +546,7 @@ export declare const runRecordSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -561,6 +631,9 @@ export declare const runRecordSchema: z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"parent-attachment">;
                     id: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"parent-file">;
+                    path: z.ZodString;
                 }, z.core.$strict>], "kind">;
                 path: z.ZodString;
                 sha256: z.ZodString;
@@ -602,38 +675,75 @@ export declare const runRecordSchema: z.ZodObject<{
             acknowledgedAt: z.ZodOptional<z.ZodISODateTime>;
             memberIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
         }, z.core.$strict>>;
+        purpose: z.ZodOptional<z.ZodLiteral<"completion-refusal">>;
     }, z.core.$strict>>>;
-    ciWait: z.ZodOptional<z.ZodObject<{
+    waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         prUrl: z.ZodString;
         repository: z.ZodString;
         prNumber: z.ZodNumber;
         headSha: z.ZodString;
         id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
+        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;
-        deadline: z.ZodISODateTime;
         phase: z.ZodEnum<{
+            cancelled: "cancelled";
             delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
+            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;
@@ -644,40 +754,279 @@ export declare const runRecordSchema: z.ZodObject<{
             truncated: z.ZodBoolean;
             diagnostic: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
-        wakeId: 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>;
-    }, z.core.$strict>>;
-    lastCiWait: z.ZodOptional<z.ZodObject<{
+        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">>>;
+    lastWaits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         prUrl: z.ZodString;
         repository: z.ZodString;
         prNumber: z.ZodNumber;
         headSha: z.ZodString;
         id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
+        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;
-        deadline: z.ZodISODateTime;
         phase: z.ZodEnum<{
+            cancelled: "cancelled";
             delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
+            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;
@@ -688,10 +1037,215 @@ export declare const runRecordSchema: z.ZodObject<{
             truncated: z.ZodBoolean;
             diagnostic: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
-        wakeId: 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>;
-    }, z.core.$strict>>;
-    lastCiWaitError: z.ZodOptional<z.ZodString>;
+        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">>>;
+    lastWaitsError: z.ZodOptional<z.ZodString>;
+    automaticWakes: z.ZodOptional<z.ZodNumber>;
+    waitDeliveryFailures: z.ZodOptional<z.ZodNumber>;
     previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
         port: z.ZodNumber;
         command: z.ZodString;
@@ -717,6 +1271,22 @@ export declare const runRecordSchema: z.ZodObject<{
     systemPrompt: z.ZodOptional<z.ZodString>;
     generateFollowups: z.ZodOptional<z.ZodBoolean>;
     autonomous: z.ZodOptional<z.ZodBoolean>;
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
+    completionAction: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        phase: z.ZodEnum<{
+            blocked: "blocked";
+            complete: "complete";
+            pending: "pending";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    archiveBlocker: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        pullRequestUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     automation: z.ZodOptional<z.ZodObject<{
         automationId: z.ZodString;
         automationRevision: z.ZodNumber;
@@ -744,6 +1314,7 @@ export declare const runRecordSchema: z.ZodObject<{
     webhook: z.ZodOptional<z.ZodObject<{
         lastDeliveredAt: z.ZodOptional<z.ZodString>;
         lastError: z.ZodOptional<z.ZodString>;
+        lastErrorWebhookId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     status: z.ZodEnum<{
         cancelled: "cancelled";
@@ -754,12 +1325,7 @@ export declare const runRecordSchema: z.ZodObject<{
         running: "running";
         waiting: "waiting";
     }>;
-    activity: z.ZodOptional<z.ZodEnum<{
-        monitoring: "monitoring";
-    }>>;
-    hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
-    monitoringWakeAt: z.ZodOptional<z.ZodString>;
-    monitoringWakeCapReached: z.ZodOptional<z.ZodBoolean>;
+    hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
     autoResumeAt: z.ZodOptional<z.ZodString>;
     autoResumeAttempts: z.ZodOptional<z.ZodNumber>;
     createdAt: z.ZodString;
@@ -770,6 +1336,14 @@ export declare const runRecordSchema: z.ZodObject<{
     outputTokens: z.ZodOptional<z.ZodNumber>;
     costUsd: z.ZodOptional<z.ZodNumber>;
     pullRequestUrl: z.ZodOptional<z.ZodString>;
+    pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        url: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            created: "created";
+            declared: "declared";
+        }>;
+    }, z.core.$strip>>>;
     referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -810,6 +1384,18 @@ export declare const runRecordSchema: z.ZodObject<{
     peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodBoolean;
     archivedAt: z.ZodOptional<z.ZodString>;
+    autoArchive: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodLiteral<"pull-requests-merged">;
+        archivedAt: z.ZodString;
+        fingerprint: z.ZodString;
+        pullRequests: z.ZodArray<z.ZodObject<{
+            owner: z.ZodString;
+            repo: z.ZodString;
+            number: z.ZodNumber;
+            mergedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    manualUnarchivedAt: z.ZodOptional<z.ZodString>;
     pinned: z.ZodOptional<z.ZodBoolean>;
     pinnedAt: z.ZodOptional<z.ZodString>;
     seenAt: z.ZodOptional<z.ZodString>;
@@ -846,6 +1432,10 @@ export declare const runRecordSchema: z.ZodObject<{
         finishedAt: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
         sessionId: z.ZodOptional<z.ZodString>;
+        sessionTransport: z.ZodOptional<z.ZodEnum<{
+            "cursor-acp": "cursor-acp";
+            "cursor-print": "cursor-print";
+        }>>;
         backend: z.ZodOptional<z.ZodEnum<{
             claude: "claude";
             codex: "codex";
@@ -892,6 +1482,18 @@ export declare const runRecordSchema: z.ZodObject<{
         }>;
         path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    handoffRecords: z.ZodOptional<z.ZodObject<{
+        autosave: z.ZodArray<z.ZodObject<{
+            at: z.ZodString;
+            note: z.ZodString;
+            periodic: z.ZodOptional<z.ZodObject<{
+                branch: z.ZodNullable<z.ZodString>;
+                count: z.ZodNumber;
+                first: z.ZodNullable<z.ZodString>;
+                latest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type RunRecord = z.infer<typeof runRecordSchema>;
 /**
@@ -929,7 +1531,15 @@ export declare const apiRunSchema: z.ZodObject<{
             lifecycle: "lifecycle";
         }>>;
         agentInputId: z.ZodOptional<z.ZodUUID>;
+        resumeContext: z.ZodOptional<z.ZodObject<{
+            failure: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodOptional<z.ZodString>;
+                error: z.ZodString;
+            }, z.core.$strip>>;
+            restarted: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
+    workflowResumeStepId: z.ZodOptional<z.ZodString>;
     invalidAsk: z.ZodOptional<z.ZodBoolean>;
     delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodLiteral<"root">;
@@ -958,14 +1568,15 @@ export declare const apiRunSchema: z.ZodObject<{
                 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.ZodArray<z.ZodObject<{
+                        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
                             label: z.ZodString;
                             description: z.ZodOptional<z.ZodString>;
-                        }, z.core.$strict>>;
+                        }, z.core.$strict>>>;
                         multiSelect: z.ZodOptional<z.ZodBoolean>;
                     }, z.core.$strict>>;
                 }, z.core.$strict>>;
@@ -979,6 +1590,7 @@ export declare const apiRunSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -1022,6 +1634,7 @@ export declare const apiRunSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -1076,6 +1689,7 @@ export declare const apiRunSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -1165,6 +1779,7 @@ export declare const apiRunSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -1219,6 +1834,7 @@ export declare const apiRunSchema: z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -1303,6 +1919,9 @@ export declare const apiRunSchema: z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"parent-attachment">;
                     id: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"parent-file">;
+                    path: z.ZodString;
                 }, z.core.$strict>], "kind">;
                 path: z.ZodString;
                 sha256: z.ZodString;
@@ -1344,38 +1963,75 @@ export declare const apiRunSchema: z.ZodObject<{
             acknowledgedAt: z.ZodOptional<z.ZodISODateTime>;
             memberIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
         }, z.core.$strict>>;
+        purpose: z.ZodOptional<z.ZodLiteral<"completion-refusal">>;
     }, z.core.$strict>>>;
-    ciWait: z.ZodOptional<z.ZodObject<{
+    waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         prUrl: z.ZodString;
         repository: z.ZodString;
         prNumber: z.ZodNumber;
         headSha: z.ZodString;
         id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
+        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;
-        deadline: z.ZodISODateTime;
         phase: z.ZodEnum<{
+            cancelled: "cancelled";
             delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
+            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;
@@ -1386,40 +2042,279 @@ export declare const apiRunSchema: z.ZodObject<{
             truncated: z.ZodBoolean;
             diagnostic: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
-        wakeId: 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>;
-    }, z.core.$strict>>;
-    lastCiWait: z.ZodOptional<z.ZodObject<{
+        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">>>;
+    lastWaits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         prUrl: z.ZodString;
         repository: z.ZodString;
         prNumber: z.ZodNumber;
         headSha: z.ZodString;
         id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
+        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;
-        deadline: z.ZodISODateTime;
         phase: z.ZodEnum<{
+            cancelled: "cancelled";
             delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
+            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;
@@ -1430,10 +2325,215 @@ export declare const apiRunSchema: z.ZodObject<{
             truncated: z.ZodBoolean;
             diagnostic: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
-        wakeId: 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>;
-    }, z.core.$strict>>;
-    lastCiWaitError: z.ZodOptional<z.ZodString>;
+        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">>>;
+    lastWaitsError: z.ZodOptional<z.ZodString>;
+    automaticWakes: z.ZodOptional<z.ZodNumber>;
+    waitDeliveryFailures: z.ZodOptional<z.ZodNumber>;
     previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
         port: z.ZodNumber;
         command: z.ZodString;
@@ -1459,6 +2559,22 @@ export declare const apiRunSchema: z.ZodObject<{
     systemPrompt: z.ZodOptional<z.ZodString>;
     generateFollowups: z.ZodOptional<z.ZodBoolean>;
     autonomous: z.ZodOptional<z.ZodBoolean>;
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
+    completionAction: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        phase: z.ZodEnum<{
+            blocked: "blocked";
+            complete: "complete";
+            pending: "pending";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    archiveBlocker: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        pullRequestUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     automation: z.ZodOptional<z.ZodObject<{
         automationId: z.ZodString;
         automationRevision: z.ZodNumber;
@@ -1486,6 +2602,7 @@ export declare const apiRunSchema: z.ZodObject<{
     webhook: z.ZodOptional<z.ZodObject<{
         lastDeliveredAt: z.ZodOptional<z.ZodString>;
         lastError: z.ZodOptional<z.ZodString>;
+        lastErrorWebhookId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     status: z.ZodEnum<{
         cancelled: "cancelled";
@@ -1496,12 +2613,7 @@ export declare const apiRunSchema: z.ZodObject<{
         running: "running";
         waiting: "waiting";
     }>;
-    activity: z.ZodOptional<z.ZodEnum<{
-        monitoring: "monitoring";
-    }>>;
-    hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
-    monitoringWakeAt: z.ZodOptional<z.ZodString>;
-    monitoringWakeCapReached: z.ZodOptional<z.ZodBoolean>;
+    hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
     autoResumeAt: z.ZodOptional<z.ZodString>;
     autoResumeAttempts: z.ZodOptional<z.ZodNumber>;
     createdAt: z.ZodString;
@@ -1512,6 +2624,14 @@ export declare const apiRunSchema: z.ZodObject<{
     outputTokens: z.ZodOptional<z.ZodNumber>;
     costUsd: z.ZodOptional<z.ZodNumber>;
     pullRequestUrl: z.ZodOptional<z.ZodString>;
+    pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        url: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            created: "created";
+            declared: "declared";
+        }>;
+    }, z.core.$strip>>>;
     referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -1552,6 +2672,18 @@ export declare const apiRunSchema: z.ZodObject<{
     peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodBoolean;
     archivedAt: z.ZodOptional<z.ZodString>;
+    autoArchive: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodLiteral<"pull-requests-merged">;
+        archivedAt: z.ZodString;
+        fingerprint: z.ZodString;
+        pullRequests: z.ZodArray<z.ZodObject<{
+            owner: z.ZodString;
+            repo: z.ZodString;
+            number: z.ZodNumber;
+            mergedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    manualUnarchivedAt: z.ZodOptional<z.ZodString>;
     pinned: z.ZodOptional<z.ZodBoolean>;
     pinnedAt: z.ZodOptional<z.ZodString>;
     seenAt: z.ZodOptional<z.ZodString>;
@@ -1588,6 +2720,10 @@ export declare const apiRunSchema: z.ZodObject<{
         finishedAt: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
         sessionId: z.ZodOptional<z.ZodString>;
+        sessionTransport: z.ZodOptional<z.ZodEnum<{
+            "cursor-acp": "cursor-acp";
+            "cursor-print": "cursor-print";
+        }>>;
         backend: z.ZodOptional<z.ZodEnum<{
             claude: "claude";
             codex: "codex";
@@ -1634,6 +2770,18 @@ export declare const apiRunSchema: z.ZodObject<{
         }>;
         path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    handoffRecords: z.ZodOptional<z.ZodObject<{
+        autosave: z.ZodArray<z.ZodObject<{
+            at: z.ZodString;
+            note: z.ZodString;
+            periodic: z.ZodOptional<z.ZodObject<{
+                branch: z.ZodNullable<z.ZodString>;
+                count: z.ZodNumber;
+                first: z.ZodNullable<z.ZodString>;
+                latest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     finishBlocked: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     cliResumeCommand: z.ZodOptional<z.ZodString>;
     usage: z.ZodOptional<z.ZodObject<{
@@ -1678,18 +2826,49 @@ export declare const runSummarySchema: z.ZodObject<{
         running: "running";
         waiting: "waiting";
     }>;
-    activity: z.ZodOptional<z.ZodEnum<{
-        monitoring: "monitoring";
-    }>>;
-    hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
-    delegation: z.ZodOptional<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";
+    hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
+    waitingOn: z.ZodOptional<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">>>;
+    waitWakePending: z.ZodOptional<z.ZodLiteral<true>>;
+    delegation: z.ZodOptional<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<{
@@ -1719,6 +2898,14 @@ export declare const runSummarySchema: z.ZodObject<{
     branch: z.ZodOptional<z.ZodString>;
     startedAt: z.ZodOptional<z.ZodString>;
     pullRequestUrl: z.ZodOptional<z.ZodString>;
+    pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        url: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            created: "created";
+            declared: "declared";
+        }>;
+    }, z.core.$strip>>>;
     referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -1739,6 +2926,7 @@ export declare const runSummarySchema: z.ZodObject<{
     groupId: z.ZodOptional<z.ZodString>;
     variant: z.ZodOptional<z.ZodString>;
     pinned: z.ZodOptional<z.ZodBoolean>;
+    automationId: z.ZodOptional<z.ZodString>;
     runner: z.ZodOptional<z.ZodEnum<{
         claude: "claude";
         codex: "codex";
@@ -1794,10 +2982,41 @@ export declare const runIndexEntrySchema: z.ZodObject<{
         running: "running";
         waiting: "waiting";
     }>;
-    activity: z.ZodOptional<z.ZodEnum<{
-        monitoring: "monitoring";
-    }>>;
-    hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
+    hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
+    waitingOn: z.ZodOptional<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">>>;
+    waitWakePending: z.ZodOptional<z.ZodLiteral<true>>;
     delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodLiteral<"root">;
         wait: z.ZodOptional<z.ZodObject<{
@@ -1835,6 +3054,14 @@ export declare const runIndexEntrySchema: z.ZodObject<{
     branch: z.ZodOptional<z.ZodString>;
     startedAt: z.ZodOptional<z.ZodString>;
     pullRequestUrl: z.ZodOptional<z.ZodString>;
+    pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        url: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            created: "created";
+            declared: "declared";
+        }>;
+    }, z.core.$strip>>>;
     referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -1855,6 +3082,7 @@ export declare const runIndexEntrySchema: z.ZodObject<{
     groupId: z.ZodOptional<z.ZodString>;
     variant: z.ZodOptional<z.ZodString>;
     pinned: z.ZodOptional<z.ZodBoolean>;
+    automationId: z.ZodOptional<z.ZodString>;
     runner: z.ZodOptional<z.ZodEnum<{
         claude: "claude";
         codex: "codex";
@@ -1888,8 +3116,6 @@ export declare const runIndexEntrySchema: z.ZodObject<{
     projectId: z.ZodString;
 }, z.core.$strip>;
 export type RunIndexEntry = z.infer<typeof runIndexEntrySchema>;
-/** `(planned)` and `(inbox)` chains carry their meaning in their first agent step's name. */
-export declare function runWorkflowLabel(run: Pick<RunRecord, 'workflow' | 'steps'>): string;
 /**
  * The one projection from a run record to its list row (#817). Optional keys are copied only when
  * present, so the wire never carries an `undefined` the schema calls absent; `delegation` goes
@@ -1897,8 +3123,17 @@ export declare function runWorkflowLabel(run: Pick<RunRecord, 'workflow' | 'step
  * the live sample a caller attached, never persisted.
  */
 export declare function toRunSummary(run: RunRecord & {
-    usage?: ProcessUsage;
+    usage?: ProcessUsage | undefined;
 }): RunSummary;
+/** The automation that launched a run, from either origin field (hearsay-tools/cezarion#1332).
+ *  Only the recorded origin counts: `autonomous`, the title and whether the definition still
+ *  exists say nothing about who started a task. */
+export declare function automationIdOf(run: Pick<RunRecord, 'automation' | 'automationTrigger'>): string | undefined;
+/** Whether a list row is an automation-created task: the sidebar's Automations tab and its
+ *  scoped "Archive all" read this, on the cockpit and in the store. */
+export declare function isAutomationTask(run: {
+    automationId?: string | undefined;
+}): boolean;
 /**
  * `GET /workspace/runs-index`.
  *
@@ -1944,9 +3179,6 @@ export declare const referenceStatusesByProjectSchema: z.ZodRecord<z.ZodString,
         "review-required": "review-required";
     }>>;
 }, z.core.$strip>>;
-/** The archived roots `GET /run-summaries/archived` answers per page by default, and at most (#864). */
-export declare const ARCHIVED_RUNS_PAGE_DEFAULT = 50;
-export declare const ARCHIVED_RUNS_PAGE_MAX = 200;
 /**
  * `GET /run-summaries?archived=` (#864). `all` (the default) is every run, as the route has always
  * answered — an older `cez task list --all` keeps getting every row. `recent` is the window the
@@ -1985,10 +3217,41 @@ export declare const archivedRunsResponseSchema: z.ZodObject<{
             running: "running";
             waiting: "waiting";
         }>;
-        activity: z.ZodOptional<z.ZodEnum<{
-            monitoring: "monitoring";
-        }>>;
-        hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
+        hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
+        waitingOn: z.ZodOptional<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">>>;
+        waitWakePending: z.ZodOptional<z.ZodLiteral<true>>;
         delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             role: z.ZodLiteral<"root">;
             wait: z.ZodOptional<z.ZodObject<{
@@ -2026,6 +3289,14 @@ export declare const archivedRunsResponseSchema: z.ZodObject<{
         branch: z.ZodOptional<z.ZodString>;
         startedAt: z.ZodOptional<z.ZodString>;
         pullRequestUrl: z.ZodOptional<z.ZodString>;
+        pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            number: z.ZodNumber;
+            url: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                created: "created";
+                declared: "declared";
+            }>;
+        }, z.core.$strip>>>;
         referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
         prNumber: z.ZodOptional<z.ZodNumber>;
         issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -2046,6 +3317,7 @@ export declare const archivedRunsResponseSchema: z.ZodObject<{
         groupId: z.ZodOptional<z.ZodString>;
         variant: z.ZodOptional<z.ZodString>;
         pinned: z.ZodOptional<z.ZodBoolean>;
+        automationId: z.ZodOptional<z.ZodString>;
         runner: z.ZodOptional<z.ZodEnum<{
             claude: "claude";
             codex: "codex";
@@ -2100,10 +3372,41 @@ export declare const runsIndexResponseSchema: z.ZodObject<{
             running: "running";
             waiting: "waiting";
         }>;
-        activity: z.ZodOptional<z.ZodEnum<{
-            monitoring: "monitoring";
-        }>>;
-        hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
+        hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
+        waitingOn: z.ZodOptional<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">>>;
+        waitWakePending: z.ZodOptional<z.ZodLiteral<true>>;
         delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             role: z.ZodLiteral<"root">;
             wait: z.ZodOptional<z.ZodObject<{
@@ -2141,6 +3444,14 @@ export declare const runsIndexResponseSchema: z.ZodObject<{
         branch: z.ZodOptional<z.ZodString>;
         startedAt: z.ZodOptional<z.ZodString>;
         pullRequestUrl: z.ZodOptional<z.ZodString>;
+        pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            number: z.ZodNumber;
+            url: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                created: "created";
+                declared: "declared";
+            }>;
+        }, z.core.$strip>>>;
         referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
         prNumber: z.ZodOptional<z.ZodNumber>;
         issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -2161,6 +3472,7 @@ export declare const runsIndexResponseSchema: z.ZodObject<{
         groupId: z.ZodOptional<z.ZodString>;
         variant: z.ZodOptional<z.ZodString>;
         pinned: z.ZodOptional<z.ZodBoolean>;
+        automationId: z.ZodOptional<z.ZodString>;
         runner: z.ZodOptional<z.ZodEnum<{
             claude: "claude";
             codex: "codex";
@@ -2252,10 +3564,41 @@ export declare const runsSearchResponseSchema: z.ZodObject<{
             running: "running";
             waiting: "waiting";
         }>;
-        activity: z.ZodOptional<z.ZodEnum<{
-            monitoring: "monitoring";
-        }>>;
-        hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
+        hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
+        waitingOn: z.ZodOptional<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">>>;
+        waitWakePending: z.ZodOptional<z.ZodLiteral<true>>;
         delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             role: z.ZodLiteral<"root">;
             wait: z.ZodOptional<z.ZodObject<{
@@ -2293,6 +3636,14 @@ export declare const runsSearchResponseSchema: z.ZodObject<{
         branch: z.ZodOptional<z.ZodString>;
         startedAt: z.ZodOptional<z.ZodString>;
         pullRequestUrl: z.ZodOptional<z.ZodString>;
+        pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            number: z.ZodNumber;
+            url: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                created: "created";
+                declared: "declared";
+            }>;
+        }, z.core.$strip>>>;
         referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
         prNumber: z.ZodOptional<z.ZodNumber>;
         issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -2313,6 +3664,7 @@ export declare const runsSearchResponseSchema: z.ZodObject<{
         groupId: z.ZodOptional<z.ZodString>;
         variant: z.ZodOptional<z.ZodString>;
         pinned: z.ZodOptional<z.ZodBoolean>;
+        automationId: z.ZodOptional<z.ZodString>;
         runner: z.ZodOptional<z.ZodEnum<{
             claude: "claude";
             codex: "codex";
@@ -2348,13 +3700,8 @@ export declare const runsSearchResponseSchema: z.ZodObject<{
     truncated: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export type RunsSearchResponse = z.infer<typeof runsSearchResponseSchema>;
-/**
- * `POST /runs` (201) — one record for ×1, a group for ×2/×3.
- *
- * The ×1 branch is the STORED record, not `ApiRun`: `startRun` answers before any `ps` sample
- * exists, so the create route never runs a record through `withUsage`.
- */
-export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+/** `POST /runs` (201) — the stored record, before any process usage sample exists. */
+export declare const createRunResponseSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
     titleSummary: z.ZodOptional<z.ZodString>;
@@ -2383,7 +3730,15 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
             lifecycle: "lifecycle";
         }>>;
         agentInputId: z.ZodOptional<z.ZodUUID>;
+        resumeContext: z.ZodOptional<z.ZodObject<{
+            failure: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodOptional<z.ZodString>;
+                error: z.ZodString;
+            }, z.core.$strip>>;
+            restarted: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
+    workflowResumeStepId: z.ZodOptional<z.ZodString>;
     invalidAsk: z.ZodOptional<z.ZodBoolean>;
     delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodLiteral<"root">;
@@ -2412,14 +3767,15 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
                 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.ZodArray<z.ZodObject<{
+                        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
                             label: z.ZodString;
                             description: z.ZodOptional<z.ZodString>;
-                        }, z.core.$strict>>;
+                        }, z.core.$strict>>>;
                         multiSelect: z.ZodOptional<z.ZodBoolean>;
                     }, z.core.$strict>>;
                 }, z.core.$strict>>;
@@ -2433,6 +3789,7 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -2476,6 +3833,7 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -2530,6 +3888,7 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -2619,6 +3978,7 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -2673,6 +4033,7 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
                     failed: "failed";
                     "human-fallback": "human-fallback";
                     replied: "replied";
+                    "replied-late": "replied-late";
                     "sender-closed": "sender-closed";
                     "timed-out": "timed-out";
                 }>;
@@ -2757,6 +4118,9 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"parent-attachment">;
                     id: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"parent-file">;
+                    path: z.ZodString;
                 }, z.core.$strict>], "kind">;
                 path: z.ZodString;
                 sha256: z.ZodString;
@@ -2798,38 +4162,75 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
             acknowledgedAt: z.ZodOptional<z.ZodISODateTime>;
             memberIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
         }, z.core.$strict>>;
+        purpose: z.ZodOptional<z.ZodLiteral<"completion-refusal">>;
     }, z.core.$strict>>>;
-    ciWait: z.ZodOptional<z.ZodObject<{
+    waits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         prUrl: z.ZodString;
         repository: z.ZodString;
         prNumber: z.ZodNumber;
         headSha: z.ZodString;
         id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
+        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;
-        deadline: z.ZodISODateTime;
         phase: z.ZodEnum<{
+            cancelled: "cancelled";
             delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
+            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;
@@ -2840,40 +4241,279 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
             truncated: z.ZodBoolean;
             diagnostic: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
-        wakeId: 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>;
-    }, z.core.$strict>>;
-    lastCiWait: z.ZodOptional<z.ZodObject<{
+        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">>>;
+    lastWaits: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         prUrl: z.ZodString;
         repository: z.ZodString;
         prNumber: z.ZodNumber;
         headSha: z.ZodString;
         id: z.ZodUUID;
-        generation: z.ZodString;
-        turnId: z.ZodString;
-        timeoutSeconds: z.ZodNumber;
+        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;
-        deadline: z.ZodISODateTime;
         phase: z.ZodEnum<{
+            cancelled: "cancelled";
             delivered: "delivered";
-            parked: "parked";
-            registered: "registered";
-            "wake-pending": "wake-pending";
-            withdrawn: "withdrawn";
+            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;
@@ -2884,35 +4524,256 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
             truncated: z.ZodBoolean;
             diagnostic: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
-        wakeId: 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>;
-    }, z.core.$strict>>;
-    lastCiWaitError: z.ZodOptional<z.ZodString>;
-    previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        port: z.ZodNumber;
-        command: z.ZodString;
-        cwd: z.ZodOptional<z.ZodString>;
-        label: z.ZodString;
-        path: z.ZodOptional<z.ZodString>;
+        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;
-        answeredAtRegistration: z.ZodBoolean;
-    }, z.core.$strip>>>;
-    taskImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    model: z.ZodOptional<z.ZodString>;
-    effort: z.ZodOptional<z.ZodString>;
-    modelIdentity: z.ZodOptional<z.ZodString>;
-    runner: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        cursor: "cursor";
-        omp: "omp";
-        opencode: "opencode";
+        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">>>;
+    lastWaitsError: z.ZodOptional<z.ZodString>;
+    automaticWakes: z.ZodOptional<z.ZodNumber>;
+    waitDeliveryFailures: z.ZodOptional<z.ZodNumber>;
+    previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        port: z.ZodNumber;
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        registeredAt: z.ZodISODateTime;
+        answeredAtRegistration: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    taskImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    modelIdentity: z.ZodOptional<z.ZodString>;
+    runner: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        cursor: "cursor";
+        omp: "omp";
+        opencode: "opencode";
         pi: "pi";
     }>>;
     agentProfile: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
     generateFollowups: z.ZodOptional<z.ZodBoolean>;
     autonomous: z.ZodOptional<z.ZodBoolean>;
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
+    completionAction: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        phase: z.ZodEnum<{
+            blocked: "blocked";
+            complete: "complete";
+            pending: "pending";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    archiveBlocker: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        pullRequestUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     automation: z.ZodOptional<z.ZodObject<{
         automationId: z.ZodString;
         automationRevision: z.ZodNumber;
@@ -2940,6 +4801,7 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
     webhook: z.ZodOptional<z.ZodObject<{
         lastDeliveredAt: z.ZodOptional<z.ZodString>;
         lastError: z.ZodOptional<z.ZodString>;
+        lastErrorWebhookId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     status: z.ZodEnum<{
         cancelled: "cancelled";
@@ -2950,12 +4812,7 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
         running: "running";
         waiting: "waiting";
     }>;
-    activity: z.ZodOptional<z.ZodEnum<{
-        monitoring: "monitoring";
-    }>>;
-    hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
-    monitoringWakeAt: z.ZodOptional<z.ZodString>;
-    monitoringWakeCapReached: z.ZodOptional<z.ZodBoolean>;
+    hasPendingPermission: z.ZodOptional<z.ZodBoolean>;
     autoResumeAt: z.ZodOptional<z.ZodString>;
     autoResumeAttempts: z.ZodOptional<z.ZodNumber>;
     createdAt: z.ZodString;
@@ -2966,6 +4823,14 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
     outputTokens: z.ZodOptional<z.ZodNumber>;
     costUsd: z.ZodOptional<z.ZodNumber>;
     pullRequestUrl: z.ZodOptional<z.ZodString>;
+    pullRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        url: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            created: "created";
+            declared: "declared";
+        }>;
+    }, z.core.$strip>>>;
     referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     issueNumber: z.ZodOptional<z.ZodNumber>;
@@ -3006,6 +4871,18 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
     peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodBoolean;
     archivedAt: z.ZodOptional<z.ZodString>;
+    autoArchive: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodLiteral<"pull-requests-merged">;
+        archivedAt: z.ZodString;
+        fingerprint: z.ZodString;
+        pullRequests: z.ZodArray<z.ZodObject<{
+            owner: z.ZodString;
+            repo: z.ZodString;
+            number: z.ZodNumber;
+            mergedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    manualUnarchivedAt: z.ZodOptional<z.ZodString>;
     pinned: z.ZodOptional<z.ZodBoolean>;
     pinnedAt: z.ZodOptional<z.ZodString>;
     seenAt: z.ZodOptional<z.ZodString>;
@@ -3042,6 +4919,10 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
         finishedAt: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
         sessionId: z.ZodOptional<z.ZodString>;
+        sessionTransport: z.ZodOptional<z.ZodEnum<{
+            "cursor-acp": "cursor-acp";
+            "cursor-print": "cursor-print";
+        }>>;
         backend: z.ZodOptional<z.ZodEnum<{
             claude: "claude";
             codex: "codex";
@@ -3088,1735 +4969,189 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
         }>;
         path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    handoffRecords: z.ZodOptional<z.ZodObject<{
+        autosave: z.ZodArray<z.ZodObject<{
+            at: z.ZodString;
+            note: z.ZodString;
+            periodic: z.ZodOptional<z.ZodObject<{
+                branch: z.ZodNullable<z.ZodString>;
+                count: z.ZodNumber;
+                first: z.ZodNullable<z.ZodString>;
+                latest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateRunResponse = z.infer<typeof createRunResponseSchema>;
+/** `POST /runs/:id/cancel` — genuinely a boolean: an already-settled run answers 200 + `false`. */
+export declare const cancelResponseSchema: z.ZodObject<{
+    cancelled: z.ZodBoolean;
+}, z.core.$strip>;
+export type CancelResponse = z.infer<typeof cancelResponseSchema>;
+/**
+ * `DELETE /runs/:id/auto-resume` (spec 2026-08-03-auto-resume-after-usage-limit) — the per-task
+ * off switch for a pending usage-limit resume, next to the workspace-wide setting.
+ *
+ * `z.literal(true)`, not a boolean, and that IS the shape: the route is idempotent, so a run with
+ * nothing pending answers 200 as well — "this task will not resume itself" is equally true either
+ * way. Only an unknown run refuses, with 404.
+ */
+export declare const cancelAutoResumeResponseSchema: z.ZodObject<{
+    cancelled: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type CancelAutoResumeResponse = z.infer<typeof cancelAutoResumeResponseSchema>;
+/** Which finished runs a sweep takes: unpinned (the sidebar's Finished group), pinned (the pinned
+ *  rows that have ended), or both when absent. Scheduled runs and owned workers are never swept. */
+export declare const archiveFinishedScopeSchema: z.ZodEnum<{
+    pinned: "pinned";
+    unpinned: "unpinned";
+}>;
+export type ArchiveFinishedScope = z.infer<typeof archiveFinishedScopeSchema>;
+/** `POST /runs/archive-finished` body — optional, an absent body sweeps both scopes. `automation`
+ *  narrows the sweep to tasks an automation launched (`true`) or to every other task (`false`):
+ *  the sidebar's Automations and Active tabs (hearsay-tools/cezarion#1332). Absent takes both. */
+export declare const archiveFinishedRequestSchema: z.ZodObject<{
+    scope: z.ZodOptional<z.ZodEnum<{
+        pinned: "pinned";
+        unpinned: "unpinned";
+    }>>;
+    automation: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ArchiveFinishedRequest = z.infer<typeof archiveFinishedRequestSchema>;
+/** `POST /runs/archive-finished` — `archived` counts every record flipped (owned workers
+ *  included), `ids` the top-level runs the sweep picked, `pinnedIds` the subset that carried a
+ *  pin before archiving dropped it (so an Undo can restore it). */
+export declare const archiveFinishedResponseSchema: z.ZodObject<{
+    archived: z.ZodNumber;
+    ids: z.ZodArray<z.ZodString>;
+    pinnedIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ArchiveFinishedResponse = z.infer<typeof archiveFinishedResponseSchema>;
+/** `POST /runs/read-all` — how many unread finished runs the sweep marked read. */
+/** `POST /runs/read-all` body — optional, an absent body stamps every origin. `automation` narrows
+ *  the sweep the same way `archiveFinishedRequestSchema` does: the Tasks pages' origin filter
+ *  (hearsay-tools/cezarion#1616). */
+export declare const markAllReadRequestSchema: z.ZodObject<{
+    automation: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MarkAllReadRequest = z.infer<typeof markAllReadRequestSchema>;
+export declare const markAllReadResponseSchema: z.ZodObject<{
+    read: z.ZodNumber;
+}, z.core.$strip>;
+export type MarkAllReadResponse = z.infer<typeof markAllReadResponseSchema>;
+/** `DELETE /runs/:id` — an active run is a 409 and an unknown one a 404, so this only ever
+ *  reports success. */
+export declare const deleteRunResponseSchema: z.ZodObject<{
+    deleted: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type DeleteRunResponse = z.infer<typeof deleteRunResponseSchema>;
+/** `POST /runs/:id/finish` — "no open session" is a 409. */
+export declare const finishResponseSchema: z.ZodObject<{
+    finished: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type FinishResponse = z.infer<typeof finishResponseSchema>;
+/** `POST /runs/:id/continue` — a refusal to reopen is a 409 carrying the engine's reason. */
+export declare const continueResponseSchema: z.ZodObject<{
+    continued: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type ContinueResponse = z.infer<typeof continueResponseSchema>;
+/**
+ * `POST /runs/:id/pr` (201, spec 009) — the draft PR's URL; `dryRun` marks the CEZ_DRY_RUN fake
+ * (no push, no gh). Failure is a 409 whose `ApiError` carries the `manual` merge command instead.
+ *
+ * `dryRun` is REQUIRED: `createDraftPr`'s success outcome always sets it (`forge/types.ts`), so
+ * the key is always on the wire. The hand-written DTO had it optional.
+ */
+export declare const createPrResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+    dryRun: z.ZodBoolean;
+}, z.core.$strip>;
+export type CreatePrResponse = z.infer<typeof createPrResponseSchema>;
+/**
+ * `POST /runs/:id/messages` — one of three shapes (#472), by how far the run has got:
+ * `delivered` (a live session took it), `queued` (still waiting for a slot, so it was stacked
+ * onto the prompt and the stored entry rides along), `deferred` (mid-spawn, so it was buffered
+ * and arrives as an ordinary follow-up turn once the session opens). Anything else is a 409.
+ *
+ * A union, not one object of optional flags: exactly one of the three keys is ever present, and
+ * the flattened DTO shape admitted `{}`. Pre-#472 clients only ever saw `delivered`.
+ */
+export declare const messageResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    delivered: z.ZodLiteral<true>;
 }, z.core.$strip>, z.ZodObject<{
-    runs: z.ZodArray<z.ZodObject<{
+    queued: z.ZodLiteral<true>;
+    message: z.ZodObject<{
         id: z.ZodString;
-        title: z.ZodString;
-        titleSummary: z.ZodOptional<z.ZodString>;
-        diffStat: z.ZodOptional<z.ZodObject<{
-            adds: z.ZodNumber;
-            dels: z.ZodNumber;
-            files: z.ZodNumber;
-            repointed: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        workflow: z.ZodString;
-        task: z.ZodString;
-        queuedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            text: z.ZodString;
-            images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            createdAt: z.ZodString;
-        }, z.core.$strip>>>;
-        stopping: z.ZodOptional<z.ZodBoolean>;
-        continuationMessage: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            text: z.ZodString;
-            images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            createdAt: z.ZodString;
-            origin: z.ZodOptional<z.ZodEnum<{
-                human: "human";
-                lifecycle: "lifecycle";
-            }>>;
-            agentInputId: z.ZodOptional<z.ZodUUID>;
-        }, z.core.$strip>>;
-        invalidAsk: z.ZodOptional<z.ZodBoolean>;
-        delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            role: z.ZodLiteral<"root">;
-            conversation: z.ZodOptional<z.ZodObject<{
-                messages: z.ZodArray<z.ZodObject<{
-                    senderRunId: z.ZodUUID;
-                    recipientRunId: z.ZodUUID;
-                    kind: z.ZodEnum<{
-                        "follow-up": "follow-up";
-                        progress: "progress";
-                        reply: "reply";
-                        request: "request";
-                    }>;
-                    requestId: z.ZodOptional<z.ZodUUID>;
-                    id: z.ZodUUID;
-                    text: z.ZodString;
-                    createdAt: z.ZodISODateTime;
-                    deadline: z.ZodOptional<z.ZodISODateTime>;
-                    requestHash: z.ZodString;
-                    state: z.ZodEnum<{
-                        accepted: "accepted";
-                        "continuation-required": "continuation-required";
-                        destroyed: "destroyed";
-                        late: "late";
-                    }>;
-                    resumed: z.ZodOptional<z.ZodLiteral<true>>;
-                    instruction: z.ZodOptional<z.ZodString>;
-                    question: z.ZodOptional<z.ZodObject<{
-                        questions: z.ZodArray<z.ZodObject<{
-                            id: z.ZodOptional<z.ZodString>;
-                            header: z.ZodString;
-                            question: z.ZodString;
-                            options: z.ZodArray<z.ZodObject<{
-                                label: z.ZodString;
-                                description: z.ZodOptional<z.ZodString>;
-                            }, z.core.$strict>>;
-                            multiSelect: z.ZodOptional<z.ZodBoolean>;
-                        }, z.core.$strict>>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>>;
-                outcomes: z.ZodArray<z.ZodObject<{
-                    requestId: z.ZodUUID;
-                    status: z.ZodEnum<{
-                        cancelled: "cancelled";
-                        "completed-without-reply": "completed-without-reply";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-            permissions: z.ZodArray<z.ZodEnum<{
-                destroy: "destroy";
-                diff: "diff";
-                inspect: "inspect";
-                spawn: "spawn";
-                steer: "steer";
-                stop: "stop";
-                wait: "wait";
-            }>>;
-            receipts: z.ZodArray<z.ZodObject<{
-                requestId: z.ZodUUID;
-                workerId: z.ZodUUID;
-                requestHash: z.ZodString;
-                deletion: z.ZodOptional<z.ZodObject<{
-                    phase: z.ZodEnum<{
-                        complete: "complete";
-                        pending: "pending";
-                    }>;
-                    revision: z.ZodNumber;
-                    resourceId: z.ZodUUID;
-                    generation: z.ZodUUID;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-            wait: z.ZodOptional<z.ZodObject<{
-                id: z.ZodUUID;
-                workerIds: z.ZodArray<z.ZodUUID>;
-                requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-                requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    requestId: z.ZodUUID;
-                    status: z.ZodEnum<{
-                        cancelled: "cancelled";
-                        "completed-without-reply": "completed-without-reply";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "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";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>>;
-                deadline: z.ZodISODateTime;
-                mode: z.ZodOptional<z.ZodEnum<{
-                    all: "all";
-                    any: "any";
-                    one: "one";
-                }>>;
-                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";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>>;
-                deadline: z.ZodISODateTime;
-                mode: z.ZodOptional<z.ZodEnum<{
-                    all: "all";
-                    any: "any";
-                    one: "one";
-                }>>;
-                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";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>>;
-                deadline: z.ZodISODateTime;
-                mode: z.ZodOptional<z.ZodEnum<{
-                    all: "all";
-                    any: "any";
-                    one: "one";
-                }>>;
-                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>], "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">>;
-        agentInputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            conversation: z.ZodOptional<z.ZodObject<{
-                senderRunId: z.ZodUUID;
-                recipientRunId: z.ZodUUID;
-                kind: z.ZodEnum<{
-                    "follow-up": "follow-up";
-                    progress: "progress";
-                    reply: "reply";
-                    request: "request";
-                }>;
-                requestId: z.ZodOptional<z.ZodUUID>;
-            }, z.core.$strict>>;
-            id: z.ZodUUID;
-            source: z.ZodEnum<{
-                agent: "agent";
-                lifecycle: "lifecycle";
-            }>;
-            parentRunId: z.ZodUUID;
-            text: z.ZodString;
-            createdAt: z.ZodISODateTime;
-            deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-            consumedAt: z.ZodOptional<z.ZodISODateTime>;
-            awaitingRead: z.ZodOptional<z.ZodLiteral<true>>;
-            inboxClaim: z.ZodOptional<z.ZodObject<{
-                receiptId: z.ZodUUID;
-                generation: z.ZodUUID;
-                expiresAt: z.ZodISODateTime;
-                acknowledgedAt: z.ZodOptional<z.ZodISODateTime>;
-                memberIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>>;
-        ciWait: z.ZodOptional<z.ZodObject<{
-            prUrl: z.ZodString;
-            repository: z.ZodString;
-            prNumber: z.ZodNumber;
-            headSha: z.ZodString;
-            id: z.ZodUUID;
-            generation: z.ZodString;
-            turnId: z.ZodString;
-            timeoutSeconds: z.ZodNumber;
-            registeredAt: z.ZodISODateTime;
-            deadline: z.ZodISODateTime;
-            phase: z.ZodEnum<{
-                delivered: "delivered";
-                parked: "parked";
-                registered: "registered";
-                "wake-pending": "wake-pending";
-                withdrawn: "withdrawn";
-            }>;
-            result: z.ZodOptional<z.ZodObject<{
-                outcome: z.ZodEnum<{
-                    cancelled: "cancelled";
-                    deadline: "deadline";
-                    error: "error";
-                    failed: "failed";
-                    head_changed: "head_changed";
-                    no_checks: "no_checks";
-                    passed: "passed";
-                    skipped: "skipped";
-                }>;
-                headSha: z.ZodString;
-                observedHeadSha: z.ZodOptional<z.ZodString>;
-                observedAt: z.ZodISODateTime;
-                checks: z.ZodArray<z.ZodObject<{
-                    name: z.ZodString;
-                    state: z.ZodString;
-                    link: z.ZodString;
-                }, z.core.$strict>>;
-                totalChecks: z.ZodNumber;
-                truncated: z.ZodBoolean;
-                diagnostic: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-            wakeId: z.ZodOptional<z.ZodString>;
-            deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strict>>;
-        lastCiWait: z.ZodOptional<z.ZodObject<{
-            prUrl: z.ZodString;
-            repository: z.ZodString;
-            prNumber: z.ZodNumber;
-            headSha: z.ZodString;
-            id: z.ZodUUID;
-            generation: z.ZodString;
-            turnId: z.ZodString;
-            timeoutSeconds: z.ZodNumber;
-            registeredAt: z.ZodISODateTime;
-            deadline: z.ZodISODateTime;
-            phase: z.ZodEnum<{
-                delivered: "delivered";
-                parked: "parked";
-                registered: "registered";
-                "wake-pending": "wake-pending";
-                withdrawn: "withdrawn";
-            }>;
-            result: z.ZodOptional<z.ZodObject<{
-                outcome: z.ZodEnum<{
-                    cancelled: "cancelled";
-                    deadline: "deadline";
-                    error: "error";
-                    failed: "failed";
-                    head_changed: "head_changed";
-                    no_checks: "no_checks";
-                    passed: "passed";
-                    skipped: "skipped";
-                }>;
-                headSha: z.ZodString;
-                observedHeadSha: z.ZodOptional<z.ZodString>;
-                observedAt: z.ZodISODateTime;
-                checks: z.ZodArray<z.ZodObject<{
-                    name: z.ZodString;
-                    state: z.ZodString;
-                    link: z.ZodString;
-                }, z.core.$strict>>;
-                totalChecks: z.ZodNumber;
-                truncated: z.ZodBoolean;
-                diagnostic: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-            wakeId: z.ZodOptional<z.ZodString>;
-            deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strict>>;
-        lastCiWaitError: z.ZodOptional<z.ZodString>;
-        previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            port: z.ZodNumber;
-            command: z.ZodString;
-            cwd: z.ZodOptional<z.ZodString>;
-            label: z.ZodString;
-            path: z.ZodOptional<z.ZodString>;
-            registeredAt: z.ZodISODateTime;
-            answeredAtRegistration: z.ZodBoolean;
-        }, z.core.$strip>>>;
-        taskImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        model: z.ZodOptional<z.ZodString>;
-        effort: z.ZodOptional<z.ZodString>;
-        modelIdentity: z.ZodOptional<z.ZodString>;
-        runner: z.ZodOptional<z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-            cursor: "cursor";
-            omp: "omp";
-            opencode: "opencode";
-            pi: "pi";
-        }>>;
-        agentProfile: z.ZodOptional<z.ZodString>;
-        systemPrompt: z.ZodOptional<z.ZodString>;
-        generateFollowups: z.ZodOptional<z.ZodBoolean>;
-        autonomous: z.ZodOptional<z.ZodBoolean>;
-        automation: z.ZodOptional<z.ZodObject<{
-            automationId: z.ZodString;
-            automationRevision: z.ZodNumber;
-            receiptId: z.ZodString;
-            event: z.ZodString;
-            githubUrl: z.ZodString;
-        }, z.core.$strip>>;
-        automationTrigger: z.ZodOptional<z.ZodObject<{
-            automationId: z.ZodString;
-            automationRevision: z.ZodNumber;
-            receiptId: z.ZodString;
-            trigger: z.ZodEnum<{
-                "catch-up": "catch-up";
-                manual: "manual";
-                schedule: "schedule";
-            }>;
-            occurrenceAt: z.ZodString;
-        }, z.core.$strip>>;
-        destroyRetry: z.ZodOptional<z.ZodObject<{
-            attempts: z.ZodNumber;
-            nextAt: z.ZodISODateTime;
-            needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strict>>;
-        notify: z.ZodOptional<z.ZodBoolean>;
-        webhook: z.ZodOptional<z.ZodObject<{
-            lastDeliveredAt: z.ZodOptional<z.ZodString>;
-            lastError: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        status: z.ZodEnum<{
-            cancelled: "cancelled";
-            done: "done";
-            failed: "failed";
-            queued: "queued";
-            review: "review";
-            running: "running";
-            waiting: "waiting";
-        }>;
-        activity: z.ZodOptional<z.ZodEnum<{
-            monitoring: "monitoring";
-        }>>;
-        hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
-        monitoringWakeAt: z.ZodOptional<z.ZodString>;
-        monitoringWakeCapReached: z.ZodOptional<z.ZodBoolean>;
-        autoResumeAt: z.ZodOptional<z.ZodString>;
-        autoResumeAttempts: z.ZodOptional<z.ZodNumber>;
-        createdAt: z.ZodString;
-        startedAt: z.ZodOptional<z.ZodString>;
-        finishedAt: z.ZodOptional<z.ZodString>;
-        tokensUsed: z.ZodNumber;
-        inputTokens: z.ZodOptional<z.ZodNumber>;
-        outputTokens: z.ZodOptional<z.ZodNumber>;
-        costUsd: z.ZodOptional<z.ZodNumber>;
-        pullRequestUrl: z.ZodOptional<z.ZodString>;
-        referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
-        prNumber: z.ZodOptional<z.ZodNumber>;
-        issueNumber: z.ZodOptional<z.ZodNumber>;
-        referencedIssueNumberSeeded: z.ZodOptional<z.ZodBoolean>;
-        titleOrigin: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            marker: "marker";
-            user: "user";
-        }>>;
-        markerRefs: z.ZodOptional<z.ZodObject<{
-            pr: z.ZodOptional<z.ZodNumber>;
-            issue: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        referencedPrCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        referencedIssueUrl: z.ZodOptional<z.ZodString>;
-        referencedIssueCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        worktree: z.ZodOptional<z.ZodLiteral<false>>;
-        worktreePath: z.ZodOptional<z.ZodString>;
-        branch: z.ZodOptional<z.ZodString>;
-        baseBranch: z.ZodOptional<z.ZodString>;
-        worktreeReclaimedAt: z.ZodOptional<z.ZodString>;
-        worktreeSetup: z.ZodOptional<z.ZodObject<{
-            status: z.ZodEnum<{
-                done: "done";
-                failed: "failed";
-                running: "running";
-            }>;
-            startedAt: z.ZodString;
-            finishedAt: z.ZodOptional<z.ZodString>;
-            durationMs: z.ZodOptional<z.ZodNumber>;
-            error: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        groupId: z.ZodOptional<z.ZodString>;
-        variant: z.ZodOptional<z.ZodString>;
-        clientRequestId: z.ZodOptional<z.ZodString>;
-        clientRequestHash: z.ZodOptional<z.ZodString>;
-        peakRssBytes: z.ZodOptional<z.ZodNumber>;
-        peakProcCount: z.ZodOptional<z.ZodNumber>;
-        archived: z.ZodBoolean;
-        archivedAt: z.ZodOptional<z.ZodString>;
-        pinned: z.ZodOptional<z.ZodBoolean>;
-        pinnedAt: z.ZodOptional<z.ZodString>;
-        seenAt: z.ZodOptional<z.ZodString>;
-        currentStepId: z.ZodOptional<z.ZodString>;
-        error: z.ZodOptional<z.ZodString>;
-        steps: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            kind: z.ZodEnum<{
-                agent: "agent";
-                check: "check";
-            }>;
-            status: z.ZodEnum<{
-                cancelled: "cancelled";
-                done: "done";
-                failed: "failed";
-                pending: "pending";
-                review: "review";
-                running: "running";
-                skipped: "skipped";
-                waiting: "waiting";
-            }>;
-            iterations: z.ZodNumber;
-            retriesUsed: z.ZodOptional<z.ZodNumber>;
-            tokensUsed: z.ZodNumber;
-            inputTokens: z.ZodOptional<z.ZodNumber>;
-            outputTokens: z.ZodOptional<z.ZodNumber>;
-            usageInvocationsStarted: z.ZodOptional<z.ZodNumber>;
-            usageInvocationsObserved: z.ZodOptional<z.ZodNumber>;
-            usageTurnsStarted: z.ZodOptional<z.ZodNumber>;
-            usageTurnsRecorded: z.ZodOptional<z.ZodNumber>;
-            usageInvocationEpoch: z.ZodOptional<z.ZodNumber>;
-            startedAt: z.ZodOptional<z.ZodString>;
-            finishedAt: z.ZodOptional<z.ZodString>;
-            error: z.ZodOptional<z.ZodString>;
-            sessionId: z.ZodOptional<z.ZodString>;
-            backend: z.ZodOptional<z.ZodEnum<{
-                claude: "claude";
-                codex: "codex";
-                cursor: "cursor";
-                omp: "omp";
-                opencode: "opencode";
-                pi: "pi";
-            }>>;
-            profileId: z.ZodOptional<z.ZodString>;
-            costUsd: z.ZodOptional<z.ZodNumber>;
-            synthetic: z.ZodOptional<z.ZodLiteral<"continuation">>;
-        }, z.core.$strip>>;
-        workflowDef: z.ZodOptional<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            steps: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                name: z.ZodOptional<z.ZodString>;
-                prompt: z.ZodOptional<z.ZodString>;
-                skill: z.ZodOptional<z.ZodString>;
-                model: z.ZodOptional<z.ZodString>;
-                effort: z.ZodOptional<z.ZodString>;
-                timeoutMs: z.ZodOptional<z.ZodNumber>;
-                runner: z.ZodOptional<z.ZodEnum<{
-                    claude: "claude";
-                    codex: "codex";
-                    cursor: "cursor";
-                    omp: "omp";
-                    opencode: "opencode";
-                    pi: "pi";
-                }>>;
-                agentProfile: z.ZodOptional<z.ZodString>;
-                allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                bashAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                command: z.ZodOptional<z.ZodString>;
-                onFail: z.ZodOptional<z.ZodObject<{
-                    retry: z.ZodString;
-                    max: z.ZodDefault<z.ZodNumber>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-            source: z.ZodEnum<{
-                "built-in": "built-in";
-                file: "file";
-            }>;
-            path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>]>;
-export type CreateRunResponse = z.infer<typeof createRunResponseSchema>;
-/** `POST /runs/:id/cancel` — genuinely a boolean: an already-settled run answers 200 + `false`. */
-export declare const cancelResponseSchema: z.ZodObject<{
-    cancelled: z.ZodBoolean;
-}, z.core.$strip>;
-export type CancelResponse = z.infer<typeof cancelResponseSchema>;
-/**
- * `DELETE /runs/:id/auto-resume` (spec 2026-08-03-auto-resume-after-usage-limit) — the per-task
- * off switch for a pending usage-limit resume, next to the workspace-wide setting.
- *
- * `z.literal(true)`, not a boolean, and that IS the shape: the route is idempotent, so a run with
- * nothing pending answers 200 as well — "this task will not resume itself" is equally true either
- * way. Only an unknown run refuses, with 404.
- */
-export declare const cancelAutoResumeResponseSchema: z.ZodObject<{
-    cancelled: z.ZodLiteral<true>;
-}, z.core.$strip>;
-export type CancelAutoResumeResponse = z.infer<typeof cancelAutoResumeResponseSchema>;
-/** Which finished runs a sweep takes: unpinned (the sidebar's Finished group), pinned (the pinned
- *  rows that have ended), or both when absent. Scheduled runs and owned workers are never swept. */
-export declare const archiveFinishedScopeSchema: z.ZodEnum<{
-    pinned: "pinned";
-    unpinned: "unpinned";
-}>;
-export type ArchiveFinishedScope = z.infer<typeof archiveFinishedScopeSchema>;
-/** `POST /runs/archive-finished` body — optional, an absent body sweeps both scopes. */
-export declare const archiveFinishedRequestSchema: z.ZodObject<{
-    scope: z.ZodOptional<z.ZodEnum<{
-        pinned: "pinned";
-        unpinned: "unpinned";
-    }>>;
-}, z.core.$strip>;
-export type ArchiveFinishedRequest = z.infer<typeof archiveFinishedRequestSchema>;
-/** `POST /runs/archive-finished` — `archived` counts every record flipped (owned workers
- *  included), `ids` the top-level runs the sweep picked, `pinnedIds` the subset that carried a
- *  pin before archiving dropped it (so an Undo can restore it). */
-export declare const archiveFinishedResponseSchema: z.ZodObject<{
-    archived: z.ZodNumber;
-    ids: z.ZodArray<z.ZodString>;
-    pinnedIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type ArchiveFinishedResponse = z.infer<typeof archiveFinishedResponseSchema>;
-/** `POST /runs/read-all` — how many unread finished runs the sweep marked read. */
-export declare const markAllReadResponseSchema: z.ZodObject<{
-    read: z.ZodNumber;
-}, z.core.$strip>;
-export type MarkAllReadResponse = z.infer<typeof markAllReadResponseSchema>;
-/** `DELETE /runs/:id` — an active run is a 409 and an unknown one a 404, so this only ever
- *  reports success. */
-export declare const deleteRunResponseSchema: z.ZodObject<{
-    deleted: z.ZodLiteral<true>;
-}, z.core.$strip>;
-export type DeleteRunResponse = z.infer<typeof deleteRunResponseSchema>;
-/** `POST /runs/:id/finish` — "no open session" is a 409. */
-export declare const finishResponseSchema: z.ZodObject<{
-    finished: z.ZodLiteral<true>;
-}, z.core.$strip>;
-export type FinishResponse = z.infer<typeof finishResponseSchema>;
-/** `POST /runs/:id/continue` — a refusal to reopen is a 409 carrying the engine's reason. */
-export declare const continueResponseSchema: z.ZodObject<{
-    continued: z.ZodLiteral<true>;
-}, z.core.$strip>;
-export type ContinueResponse = z.infer<typeof continueResponseSchema>;
-/**
- * `POST /runs/:id/pr` (201, spec 009) — the draft PR's URL; `dryRun` marks the CEZ_DRY_RUN fake
- * (no push, no gh). Failure is a 409 whose `ApiError` carries the `manual` merge command instead.
- *
- * `dryRun` is REQUIRED: `createDraftPr`'s success outcome always sets it (`forge/types.ts`), so
- * the key is always on the wire. The hand-written DTO had it optional.
- */
-export declare const createPrResponseSchema: z.ZodObject<{
-    url: z.ZodString;
-    dryRun: z.ZodBoolean;
-}, z.core.$strip>;
-export type CreatePrResponse = z.infer<typeof createPrResponseSchema>;
-/**
- * `POST /runs/:id/messages` — one of three shapes (#472), by how far the run has got:
- * `delivered` (a live session took it), `queued` (still waiting for a slot, so it was stacked
- * onto the prompt and the stored entry rides along), `deferred` (mid-spawn, so it was buffered
- * and arrives as an ordinary follow-up turn once the session opens). Anything else is a 409.
- *
- * A union, not one object of optional flags: exactly one of the three keys is ever present, and
- * the flattened DTO shape admitted `{}`. Pre-#472 clients only ever saw `delivered`.
- */
-export declare const messageResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
-    delivered: z.ZodLiteral<true>;
-}, z.core.$strip>, z.ZodObject<{
-    queued: z.ZodLiteral<true>;
-    message: z.ZodObject<{
-        id: z.ZodString;
-        text: z.ZodString;
-        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        createdAt: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    deferred: z.ZodLiteral<true>;
-}, z.core.$strip>]>;
-export type MessageResponse = z.infer<typeof messageResponseSchema>;
-/** `PATCH /runs/:id/queued-messages/:msgId` (#472) — the replaced entry. */
-export declare const editQueuedMessageResponseSchema: z.ZodObject<{
-    message: z.ZodObject<{
-        id: z.ZodString;
-        text: z.ZodString;
-        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        createdAt: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type EditQueuedMessageResponse = z.infer<typeof editQueuedMessageResponseSchema>;
-/** `DELETE /runs/:id/queued-messages/:msgId` (#472) — `409 run already started` otherwise. */
-export declare const removeQueuedMessageResponseSchema: z.ZodObject<{
-    removed: z.ZodLiteral<true>;
-}, z.core.$strip>;
-export type RemoveQueuedMessageResponse = z.infer<typeof removeQueuedMessageResponseSchema>;
-/**
- * `POST /runs/:id/open-in-cli` — a terminal was spawned with `command` running in it. With no
- * terminal emulator the server answers 409 and the `ApiError` carries the full `cd … && <command>`
- * for the clipboard fallback.
- */
-export declare const openInCliResponseSchema: z.ZodObject<{
-    opened: z.ZodLiteral<true>;
-    command: z.ZodString;
-}, z.core.$strip>;
-export type OpenInCliResponse = z.infer<typeof openInCliResponseSchema>;
-/** `POST /runs/:id/remove-worktree` — per-row delete in the worktrees panel (#483). */
-export declare const removeWorktreeResponseSchema: z.ZodObject<{
-    removed: z.ZodLiteral<true>;
-}, z.core.$strip>;
-export type RemoveWorktreeResponse = z.infer<typeof removeWorktreeResponseSchema>;
-/** `POST /runs/:id/git/commit` — `git add -A && git commit` in the run's worktree. */
-export declare const gitCommitResponseSchema: z.ZodObject<{
-    committed: z.ZodLiteral<true>;
-    sha: z.ZodString;
-}, z.core.$strip>;
-export type GitCommitResponse = z.infer<typeof gitCommitResponseSchema>;
-/** `POST /runs/:id/git/push` — push the worktree's branch, setting upstream if it has none. */
-export declare const gitPushResponseSchema: z.ZodObject<{
-    pushed: z.ZodLiteral<true>;
-    branch: z.ZodString;
-    remote: z.ZodString;
-    upstreamSet: z.ZodBoolean;
-}, z.core.$strip>;
-export type GitPushResponse = z.infer<typeof gitPushResponseSchema>;
-/** A commit a run made on its worktree branch. */
-export declare const runCommitSchema: z.ZodObject<{
-    sha: z.ZodString;
-    subject: z.ZodString;
-    author: z.ZodString;
-    when: z.ZodString;
-}, z.core.$strip>;
-export type RunCommit = z.infer<typeof runCommitSchema>;
-/** `GET /runs/:id/commits` — `<base>..HEAD` on the worktree branch, newest first. */
-export declare const runCommitsResponseSchema: z.ZodObject<{
-    commits: z.ZodArray<z.ZodObject<{
-        sha: z.ZodString;
-        subject: z.ZodString;
-        author: z.ZodString;
-        when: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type RunCommitsResponse = z.infer<typeof runCommitsResponseSchema>;
-/**
- * One variant column of the compare view.
- *
- * CAREFUL: `diffStat` here is the raw `git diff --stat` TEXT the server runs in the variant's
- * worktree — a different thing from the numeric `RunRecord.diffStat`. `''` when the worktree
- * is gone.
- */
-export declare const groupVariantSchema: z.ZodObject<{
-    id: z.ZodString;
-    variant: z.ZodString;
-    title: z.ZodString;
-    status: z.ZodEnum<{
-        cancelled: "cancelled";
-        done: "done";
-        failed: "failed";
-        queued: "queued";
-        review: "review";
-        running: "running";
-        waiting: "waiting";
-    }>;
-    archived: z.ZodBoolean;
-    tokensUsed: z.ZodNumber;
-    inputTokens: z.ZodOptional<z.ZodNumber>;
-    outputTokens: z.ZodOptional<z.ZodNumber>;
-    costUsd: z.ZodOptional<z.ZodNumber>;
-    diffStat: z.ZodString;
-    handoffExcerpt: z.ZodString;
-}, z.core.$strip>;
-export type GroupVariant = z.infer<typeof groupVariantSchema>;
-/** `GET /groups/:groupId` — every run sharing a groupId, side by side. */
-export declare const groupResponseSchema: z.ZodObject<{
-    groupId: z.ZodString;
-    runs: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        variant: z.ZodString;
-        title: z.ZodString;
-        status: z.ZodEnum<{
-            cancelled: "cancelled";
-            done: "done";
-            failed: "failed";
-            queued: "queued";
-            review: "review";
-            running: "running";
-            waiting: "waiting";
-        }>;
-        archived: z.ZodBoolean;
-        tokensUsed: z.ZodNumber;
-        inputTokens: z.ZodOptional<z.ZodNumber>;
-        outputTokens: z.ZodOptional<z.ZodNumber>;
-        costUsd: z.ZodOptional<z.ZodNumber>;
-        diffStat: z.ZodString;
-        handoffExcerpt: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type GroupResponse = z.infer<typeof groupResponseSchema>;
-/**
- * `POST /groups/:groupId/pick` — the winner (parked at `review` when it has a diff); the losers
- * were cancelled if alive, archived, and their worktrees + branches removed.
- *
- * `winner` is OPTIONAL because that is what the wire says: `store.getRun(id)` can miss, and
- * `JSON.stringify` drops a key whose value is `undefined`. The handler spreads the key in
- * conditionally (`server.ts`, the `/groups/:groupId/pick` route) so its own type says the same
- * thing — the two-way check in `contract-parity.workflows.test.ts` is what pins that.
- */
-export declare const pickVariantResponseSchema: z.ZodObject<{
-    winner: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        titleSummary: z.ZodOptional<z.ZodString>;
-        diffStat: z.ZodOptional<z.ZodObject<{
-            adds: z.ZodNumber;
-            dels: z.ZodNumber;
-            files: z.ZodNumber;
-            repointed: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        workflow: z.ZodString;
-        task: z.ZodString;
-        queuedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            text: z.ZodString;
-            images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            createdAt: z.ZodString;
-        }, z.core.$strip>>>;
-        stopping: z.ZodOptional<z.ZodBoolean>;
-        continuationMessage: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            text: z.ZodString;
-            images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            createdAt: z.ZodString;
-            origin: z.ZodOptional<z.ZodEnum<{
-                human: "human";
-                lifecycle: "lifecycle";
-            }>>;
-            agentInputId: z.ZodOptional<z.ZodUUID>;
-        }, z.core.$strip>>;
-        invalidAsk: z.ZodOptional<z.ZodBoolean>;
-        delegation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            role: z.ZodLiteral<"root">;
-            conversation: z.ZodOptional<z.ZodObject<{
-                messages: z.ZodArray<z.ZodObject<{
-                    senderRunId: z.ZodUUID;
-                    recipientRunId: z.ZodUUID;
-                    kind: z.ZodEnum<{
-                        "follow-up": "follow-up";
-                        progress: "progress";
-                        reply: "reply";
-                        request: "request";
-                    }>;
-                    requestId: z.ZodOptional<z.ZodUUID>;
-                    id: z.ZodUUID;
-                    text: z.ZodString;
-                    createdAt: z.ZodISODateTime;
-                    deadline: z.ZodOptional<z.ZodISODateTime>;
-                    requestHash: z.ZodString;
-                    state: z.ZodEnum<{
-                        accepted: "accepted";
-                        "continuation-required": "continuation-required";
-                        destroyed: "destroyed";
-                        late: "late";
-                    }>;
-                    resumed: z.ZodOptional<z.ZodLiteral<true>>;
-                    instruction: z.ZodOptional<z.ZodString>;
-                    question: z.ZodOptional<z.ZodObject<{
-                        questions: z.ZodArray<z.ZodObject<{
-                            id: z.ZodOptional<z.ZodString>;
-                            header: z.ZodString;
-                            question: z.ZodString;
-                            options: z.ZodArray<z.ZodObject<{
-                                label: z.ZodString;
-                                description: z.ZodOptional<z.ZodString>;
-                            }, z.core.$strict>>;
-                            multiSelect: z.ZodOptional<z.ZodBoolean>;
-                        }, z.core.$strict>>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>>;
-                outcomes: z.ZodArray<z.ZodObject<{
-                    requestId: z.ZodUUID;
-                    status: z.ZodEnum<{
-                        cancelled: "cancelled";
-                        "completed-without-reply": "completed-without-reply";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-            permissions: z.ZodArray<z.ZodEnum<{
-                destroy: "destroy";
-                diff: "diff";
-                inspect: "inspect";
-                spawn: "spawn";
-                steer: "steer";
-                stop: "stop";
-                wait: "wait";
-            }>>;
-            receipts: z.ZodArray<z.ZodObject<{
-                requestId: z.ZodUUID;
-                workerId: z.ZodUUID;
-                requestHash: z.ZodString;
-                deletion: z.ZodOptional<z.ZodObject<{
-                    phase: z.ZodEnum<{
-                        complete: "complete";
-                        pending: "pending";
-                    }>;
-                    revision: z.ZodNumber;
-                    resourceId: z.ZodUUID;
-                    generation: z.ZodUUID;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-            wait: z.ZodOptional<z.ZodObject<{
-                id: z.ZodUUID;
-                workerIds: z.ZodArray<z.ZodUUID>;
-                requestIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-                requestOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    requestId: z.ZodUUID;
-                    status: z.ZodEnum<{
-                        cancelled: "cancelled";
-                        "completed-without-reply": "completed-without-reply";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "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";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>>;
-                deadline: z.ZodISODateTime;
-                mode: z.ZodOptional<z.ZodEnum<{
-                    all: "all";
-                    any: "any";
-                    one: "one";
-                }>>;
-                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";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>>;
-                deadline: z.ZodISODateTime;
-                mode: z.ZodOptional<z.ZodEnum<{
-                    all: "all";
-                    any: "any";
-                    one: "one";
-                }>>;
-                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";
-                        destroyed: "destroyed";
-                        failed: "failed";
-                        "human-fallback": "human-fallback";
-                        replied: "replied";
-                        "sender-closed": "sender-closed";
-                        "timed-out": "timed-out";
-                    }>;
-                    observedAt: z.ZodISODateTime;
-                    replyId: z.ZodOptional<z.ZodUUID>;
-                }, z.core.$strict>>>;
-                deadline: z.ZodISODateTime;
-                mode: z.ZodOptional<z.ZodEnum<{
-                    all: "all";
-                    any: "any";
-                    one: "one";
-                }>>;
-                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>], "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">>;
-        agentInputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            conversation: z.ZodOptional<z.ZodObject<{
-                senderRunId: z.ZodUUID;
-                recipientRunId: z.ZodUUID;
-                kind: z.ZodEnum<{
-                    "follow-up": "follow-up";
-                    progress: "progress";
-                    reply: "reply";
-                    request: "request";
-                }>;
-                requestId: z.ZodOptional<z.ZodUUID>;
-            }, z.core.$strict>>;
-            id: z.ZodUUID;
-            source: z.ZodEnum<{
-                agent: "agent";
-                lifecycle: "lifecycle";
-            }>;
-            parentRunId: z.ZodUUID;
-            text: z.ZodString;
-            createdAt: z.ZodISODateTime;
-            deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-            consumedAt: z.ZodOptional<z.ZodISODateTime>;
-            awaitingRead: z.ZodOptional<z.ZodLiteral<true>>;
-            inboxClaim: z.ZodOptional<z.ZodObject<{
-                receiptId: z.ZodUUID;
-                generation: z.ZodUUID;
-                expiresAt: z.ZodISODateTime;
-                acknowledgedAt: z.ZodOptional<z.ZodISODateTime>;
-                memberIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>>;
-        ciWait: z.ZodOptional<z.ZodObject<{
-            prUrl: z.ZodString;
-            repository: z.ZodString;
-            prNumber: z.ZodNumber;
-            headSha: z.ZodString;
-            id: z.ZodUUID;
-            generation: z.ZodString;
-            turnId: z.ZodString;
-            timeoutSeconds: z.ZodNumber;
-            registeredAt: z.ZodISODateTime;
-            deadline: z.ZodISODateTime;
-            phase: z.ZodEnum<{
-                delivered: "delivered";
-                parked: "parked";
-                registered: "registered";
-                "wake-pending": "wake-pending";
-                withdrawn: "withdrawn";
-            }>;
-            result: z.ZodOptional<z.ZodObject<{
-                outcome: z.ZodEnum<{
-                    cancelled: "cancelled";
-                    deadline: "deadline";
-                    error: "error";
-                    failed: "failed";
-                    head_changed: "head_changed";
-                    no_checks: "no_checks";
-                    passed: "passed";
-                    skipped: "skipped";
-                }>;
-                headSha: z.ZodString;
-                observedHeadSha: z.ZodOptional<z.ZodString>;
-                observedAt: z.ZodISODateTime;
-                checks: z.ZodArray<z.ZodObject<{
-                    name: z.ZodString;
-                    state: z.ZodString;
-                    link: z.ZodString;
-                }, z.core.$strict>>;
-                totalChecks: z.ZodNumber;
-                truncated: z.ZodBoolean;
-                diagnostic: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-            wakeId: z.ZodOptional<z.ZodString>;
-            deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strict>>;
-        lastCiWait: z.ZodOptional<z.ZodObject<{
-            prUrl: z.ZodString;
-            repository: z.ZodString;
-            prNumber: z.ZodNumber;
-            headSha: z.ZodString;
-            id: z.ZodUUID;
-            generation: z.ZodString;
-            turnId: z.ZodString;
-            timeoutSeconds: z.ZodNumber;
-            registeredAt: z.ZodISODateTime;
-            deadline: z.ZodISODateTime;
-            phase: z.ZodEnum<{
-                delivered: "delivered";
-                parked: "parked";
-                registered: "registered";
-                "wake-pending": "wake-pending";
-                withdrawn: "withdrawn";
-            }>;
-            result: z.ZodOptional<z.ZodObject<{
-                outcome: z.ZodEnum<{
-                    cancelled: "cancelled";
-                    deadline: "deadline";
-                    error: "error";
-                    failed: "failed";
-                    head_changed: "head_changed";
-                    no_checks: "no_checks";
-                    passed: "passed";
-                    skipped: "skipped";
-                }>;
-                headSha: z.ZodString;
-                observedHeadSha: z.ZodOptional<z.ZodString>;
-                observedAt: z.ZodISODateTime;
-                checks: z.ZodArray<z.ZodObject<{
-                    name: z.ZodString;
-                    state: z.ZodString;
-                    link: z.ZodString;
-                }, z.core.$strict>>;
-                totalChecks: z.ZodNumber;
-                truncated: z.ZodBoolean;
-                diagnostic: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-            wakeId: z.ZodOptional<z.ZodString>;
-            deliveredAt: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strict>>;
-        lastCiWaitError: z.ZodOptional<z.ZodString>;
-        previewServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            port: z.ZodNumber;
-            command: z.ZodString;
-            cwd: z.ZodOptional<z.ZodString>;
-            label: z.ZodString;
-            path: z.ZodOptional<z.ZodString>;
-            registeredAt: z.ZodISODateTime;
-            answeredAtRegistration: z.ZodBoolean;
-        }, z.core.$strip>>>;
-        taskImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        model: z.ZodOptional<z.ZodString>;
-        effort: z.ZodOptional<z.ZodString>;
-        modelIdentity: z.ZodOptional<z.ZodString>;
-        runner: z.ZodOptional<z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-            cursor: "cursor";
-            omp: "omp";
-            opencode: "opencode";
-            pi: "pi";
-        }>>;
-        agentProfile: z.ZodOptional<z.ZodString>;
-        systemPrompt: z.ZodOptional<z.ZodString>;
-        generateFollowups: z.ZodOptional<z.ZodBoolean>;
-        autonomous: z.ZodOptional<z.ZodBoolean>;
-        automation: z.ZodOptional<z.ZodObject<{
-            automationId: z.ZodString;
-            automationRevision: z.ZodNumber;
-            receiptId: z.ZodString;
-            event: z.ZodString;
-            githubUrl: z.ZodString;
-        }, z.core.$strip>>;
-        automationTrigger: z.ZodOptional<z.ZodObject<{
-            automationId: z.ZodString;
-            automationRevision: z.ZodNumber;
-            receiptId: z.ZodString;
-            trigger: z.ZodEnum<{
-                "catch-up": "catch-up";
-                manual: "manual";
-                schedule: "schedule";
-            }>;
-            occurrenceAt: z.ZodString;
-        }, z.core.$strip>>;
-        destroyRetry: z.ZodOptional<z.ZodObject<{
-            attempts: z.ZodNumber;
-            nextAt: z.ZodISODateTime;
-            needsAttention: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strict>>;
-        notify: z.ZodOptional<z.ZodBoolean>;
-        webhook: z.ZodOptional<z.ZodObject<{
-            lastDeliveredAt: z.ZodOptional<z.ZodString>;
-            lastError: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        status: z.ZodEnum<{
-            cancelled: "cancelled";
-            done: "done";
-            failed: "failed";
-            queued: "queued";
-            review: "review";
-            running: "running";
-            waiting: "waiting";
-        }>;
-        activity: z.ZodOptional<z.ZodEnum<{
-            monitoring: "monitoring";
-        }>>;
-        hasPendingHumanAsk: z.ZodOptional<z.ZodBoolean>;
-        monitoringWakeAt: z.ZodOptional<z.ZodString>;
-        monitoringWakeCapReached: z.ZodOptional<z.ZodBoolean>;
-        autoResumeAt: z.ZodOptional<z.ZodString>;
-        autoResumeAttempts: z.ZodOptional<z.ZodNumber>;
+        text: z.ZodString;
+        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
         createdAt: z.ZodString;
-        startedAt: z.ZodOptional<z.ZodString>;
-        finishedAt: z.ZodOptional<z.ZodString>;
-        tokensUsed: z.ZodNumber;
-        inputTokens: z.ZodOptional<z.ZodNumber>;
-        outputTokens: z.ZodOptional<z.ZodNumber>;
-        costUsd: z.ZodOptional<z.ZodNumber>;
-        pullRequestUrl: z.ZodOptional<z.ZodString>;
-        referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
-        prNumber: z.ZodOptional<z.ZodNumber>;
-        issueNumber: z.ZodOptional<z.ZodNumber>;
-        referencedIssueNumberSeeded: z.ZodOptional<z.ZodBoolean>;
-        titleOrigin: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            marker: "marker";
-            user: "user";
-        }>>;
-        markerRefs: z.ZodOptional<z.ZodObject<{
-            pr: z.ZodOptional<z.ZodNumber>;
-            issue: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        referencedPrCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        referencedIssueUrl: z.ZodOptional<z.ZodString>;
-        referencedIssueCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        worktree: z.ZodOptional<z.ZodLiteral<false>>;
-        worktreePath: z.ZodOptional<z.ZodString>;
-        branch: z.ZodOptional<z.ZodString>;
-        baseBranch: z.ZodOptional<z.ZodString>;
-        worktreeReclaimedAt: z.ZodOptional<z.ZodString>;
-        worktreeSetup: z.ZodOptional<z.ZodObject<{
-            status: z.ZodEnum<{
-                done: "done";
-                failed: "failed";
-                running: "running";
-            }>;
-            startedAt: z.ZodString;
-            finishedAt: z.ZodOptional<z.ZodString>;
-            durationMs: z.ZodOptional<z.ZodNumber>;
-            error: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        groupId: z.ZodOptional<z.ZodString>;
-        variant: z.ZodOptional<z.ZodString>;
-        clientRequestId: z.ZodOptional<z.ZodString>;
-        clientRequestHash: z.ZodOptional<z.ZodString>;
-        peakRssBytes: z.ZodOptional<z.ZodNumber>;
-        peakProcCount: z.ZodOptional<z.ZodNumber>;
-        archived: z.ZodBoolean;
-        archivedAt: z.ZodOptional<z.ZodString>;
-        pinned: z.ZodOptional<z.ZodBoolean>;
-        pinnedAt: z.ZodOptional<z.ZodString>;
-        seenAt: z.ZodOptional<z.ZodString>;
-        currentStepId: z.ZodOptional<z.ZodString>;
-        error: z.ZodOptional<z.ZodString>;
-        steps: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            kind: z.ZodEnum<{
-                agent: "agent";
-                check: "check";
-            }>;
-            status: z.ZodEnum<{
-                cancelled: "cancelled";
-                done: "done";
-                failed: "failed";
-                pending: "pending";
-                review: "review";
-                running: "running";
-                skipped: "skipped";
-                waiting: "waiting";
-            }>;
-            iterations: z.ZodNumber;
-            retriesUsed: z.ZodOptional<z.ZodNumber>;
-            tokensUsed: z.ZodNumber;
-            inputTokens: z.ZodOptional<z.ZodNumber>;
-            outputTokens: z.ZodOptional<z.ZodNumber>;
-            usageInvocationsStarted: z.ZodOptional<z.ZodNumber>;
-            usageInvocationsObserved: z.ZodOptional<z.ZodNumber>;
-            usageTurnsStarted: z.ZodOptional<z.ZodNumber>;
-            usageTurnsRecorded: z.ZodOptional<z.ZodNumber>;
-            usageInvocationEpoch: z.ZodOptional<z.ZodNumber>;
-            startedAt: z.ZodOptional<z.ZodString>;
-            finishedAt: z.ZodOptional<z.ZodString>;
-            error: z.ZodOptional<z.ZodString>;
-            sessionId: z.ZodOptional<z.ZodString>;
-            backend: z.ZodOptional<z.ZodEnum<{
-                claude: "claude";
-                codex: "codex";
-                cursor: "cursor";
-                omp: "omp";
-                opencode: "opencode";
-                pi: "pi";
-            }>>;
-            profileId: z.ZodOptional<z.ZodString>;
-            costUsd: z.ZodOptional<z.ZodNumber>;
-            synthetic: z.ZodOptional<z.ZodLiteral<"continuation">>;
-        }, z.core.$strip>>;
-        workflowDef: z.ZodOptional<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            steps: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                name: z.ZodOptional<z.ZodString>;
-                prompt: z.ZodOptional<z.ZodString>;
-                skill: z.ZodOptional<z.ZodString>;
-                model: z.ZodOptional<z.ZodString>;
-                effort: z.ZodOptional<z.ZodString>;
-                timeoutMs: z.ZodOptional<z.ZodNumber>;
-                runner: z.ZodOptional<z.ZodEnum<{
-                    claude: "claude";
-                    codex: "codex";
-                    cursor: "cursor";
-                    omp: "omp";
-                    opencode: "opencode";
-                    pi: "pi";
-                }>>;
-                agentProfile: z.ZodOptional<z.ZodString>;
-                allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                bashAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                command: z.ZodOptional<z.ZodString>;
-                onFail: z.ZodOptional<z.ZodObject<{
-                    retry: z.ZodString;
-                    max: z.ZodDefault<z.ZodNumber>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-            source: z.ZodEnum<{
-                "built-in": "built-in";
-                file: "file";
-            }>;
-            path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    deferred: z.ZodLiteral<true>;
+}, z.core.$strip>]>;
+export type MessageResponse = z.infer<typeof messageResponseSchema>;
+/** `PATCH /runs/:id/queued-messages/:msgId` (#472) — the replaced entry. */
+export declare const editQueuedMessageResponseSchema: z.ZodObject<{
+    message: z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
 }, z.core.$strip>;
-export type PickVariantResponse = z.infer<typeof pickVariantResponseSchema>;
-/**
- * Non-image attachment types the composer may send (#950). Deliberately an allowlist and
- * deliberately short: cezar serves these files back from the cockpit's own origin, so every entry
- * here is one more thing that must be safe to hand a browser. `image/*` stays a regex — narrowing
- * what the route has always accepted would be the breaking half of this change.
- *
- * `text/x-markdown` is the spelling some browsers still report for a `.md`.
- */
-export declare const FILE_ATTACHMENT_MEDIA_TYPES: readonly ['text/plain', 'text/markdown', 'text/x-markdown', 'application/pdf'];
-/** Does this media type travel as an inline image block the model can look at? */
-export declare function isImageMediaType(mediaType: string): boolean;
-/** Is this something the composer may attach at all — an image, or one of the file types above? */
-export declare function isAttachmentMediaType(mediaType: string): boolean;
-/**
- * The on-disk extension for an attachment, derived from its media type ALONE — the user's own
- * filename never reaches the wire, and therefore never reaches a path. `img` is the pre-existing
- * catch-all for an image type cezar does not name (an SVG, a BMP), kept so those files land where
- * they always did.
- */
-export declare function attachmentExtension(mediaType: string): string;
+export type EditQueuedMessageResponse = z.infer<typeof editQueuedMessageResponseSchema>;
+/** `DELETE /runs/:id/queued-messages/:msgId` (#472) — `409 run already started` otherwise. */
+export declare const removeQueuedMessageResponseSchema: z.ZodObject<{
+    removed: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type RemoveQueuedMessageResponse = z.infer<typeof removeQueuedMessageResponseSchema>;
 /**
- * Does a persisted attachment name (`pasted-3.pdf`, `screenshot-1.png`) refer to an image?
- *
- * The one predicate every reader branches on — the engine deciding whether to re-encode a file as
- * an image block, and the cockpit deciding between a thumbnail and a named chip. Branch on the
- * NAME, never on the list an entry came from: images and files share one list and one numbering
- * space on disk, and that is what keeps the orphan sweep, the restart re-read and the per-stack
- * cap on a single code path.
+ * `POST /runs/:id/open-in-cli` — a terminal was spawned with `command` running in it. With no
+ * terminal emulator the server answers 409 and the `ApiError` carries the full `cd … && <command>`
+ * for the clipboard fallback.
  */
-export declare function isImageAttachmentName(name: string): boolean;
+export declare const openInCliResponseSchema: z.ZodObject<{
+    opened: z.ZodLiteral<true>;
+    command: z.ZodString;
+}, z.core.$strip>;
+export type OpenInCliResponse = z.infer<typeof openInCliResponseSchema>;
+/** `POST /runs/:id/remove-worktree` — per-row delete in the worktrees panel (#483). */
+export declare const removeWorktreeResponseSchema: z.ZodObject<{
+    removed: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type RemoveWorktreeResponse = z.infer<typeof removeWorktreeResponseSchema>;
+/** `POST /runs/:id/git/commit` — `git add -A && git commit` in the run's worktree. */
+export declare const gitCommitResponseSchema: z.ZodObject<{
+    committed: z.ZodLiteral<true>;
+    sha: z.ZodString;
+}, z.core.$strip>;
+export type GitCommitResponse = z.infer<typeof gitCommitResponseSchema>;
+/** `POST /runs/:id/git/push` — push the worktree's branch, setting upstream if it has none. */
+export declare const gitPushResponseSchema: z.ZodObject<{
+    pushed: z.ZodLiteral<true>;
+    branch: z.ZodString;
+    remote: z.ZodString;
+    upstreamSet: z.ZodBoolean;
+}, z.core.$strip>;
+export type GitPushResponse = z.infer<typeof gitPushResponseSchema>;
+/** A commit a run made on its worktree branch. */
+export declare const runCommitSchema: z.ZodObject<{
+    sha: z.ZodString;
+    subject: z.ZodString;
+    author: z.ZodString;
+    when: z.ZodString;
+}, z.core.$strip>;
+export type RunCommit = z.infer<typeof runCommitSchema>;
+/** `GET /runs/:id/commits` — `<base>..HEAD` on the worktree branch, newest first. */
+export declare const runCommitsResponseSchema: z.ZodObject<{
+    commits: z.ZodArray<z.ZodObject<{
+        sha: z.ZodString;
+        subject: z.ZodString;
+        author: z.ZodString;
+        when: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunCommitsResponse = z.infer<typeof runCommitsResponseSchema>;
 /**
  * One inline attachment, base64 — ≤4 per request, 7,000,000 encoded characters each.
  *
@@ -4842,8 +5177,9 @@ export declare const imageInputSchema: z.ZodObject<{
     data: z.ZodString;
 }, z.core.$strip>;
 export type ImageInput = AttachmentInput;
-/** A request id names one run, so it cannot ask for ×2/×3. */
-export declare const CLIENT_REQUEST_VARIANTS_ERROR = "clientRequestId names one run; it cannot be combined with variants > 1";
+export declare const PARALLEL_VARIANTS_REMOVED = "Parallel variants are removed. Use owned workers to compare approaches; collect their results and integrate the chosen commits explicitly.";
+/** A refusal fence for older callers: never strip a candidate count and launch one run. */
+export declare const singleRunVariantsSchema: z.ZodOptional<z.ZodLiteral<1>>;
 /**
  * The KEYS of `POST /runs`' body, before the XOR refinement that `createRunInputSchema` adds.
  *
@@ -4891,16 +5227,16 @@ export declare const createRunInputBaseSchema: z.ZodObject<{
         pi: "pi";
     }>>;
     agentProfile: z.ZodOptional<z.ZodString>;
-    variants: z.ZodOptional<z.ZodNumber>;
+    variants: z.ZodOptional<z.ZodLiteral<1>>;
     worktree: z.ZodOptional<z.ZodBoolean>;
     autonomous: z.ZodOptional<z.ZodBoolean>;
-    generateFollowups: z.ZodOptional<z.ZodBoolean>;
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
     systemPrompt: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     images: z.ZodOptional<z.ZodArray<z.ZodObject<{
         mediaType: z.ZodString;
         data: z.ZodString;
     }, z.core.$strip>>>;
-    todoId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * `POST /runs`. Exactly one of `workflow` / `steps` — the server rejects both or neither.
@@ -4947,16 +5283,16 @@ export declare const createRunInputSchema: z.ZodObject<{
         pi: "pi";
     }>>;
     agentProfile: z.ZodOptional<z.ZodString>;
-    variants: z.ZodOptional<z.ZodNumber>;
+    variants: z.ZodOptional<z.ZodLiteral<1>>;
     worktree: z.ZodOptional<z.ZodBoolean>;
     autonomous: z.ZodOptional<z.ZodBoolean>;
-    generateFollowups: z.ZodOptional<z.ZodBoolean>;
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
     systemPrompt: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     images: z.ZodOptional<z.ZodArray<z.ZodObject<{
         mediaType: z.ZodString;
         data: z.ZodString;
     }, z.core.$strip>>>;
-    todoId: z.ZodOptional<z.ZodString>;
     clientRequestId: z.ZodOptional<z.ZodString>;
     notify: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
@@ -4983,6 +5319,8 @@ export type MessageInput = z.input<typeof messageInputSchema>;
 export declare const patchRunInputSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     task: z.ZodOptional<z.ZodString>;
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type PatchRunInput = z.input<typeof patchRunInputSchema>;
 /** Per-project pin mutation. An absent flag pins; false removes both pin fields. */