@wjarka/cezarion 0.15.1 → 0.16.0

package/dist/contract/index.js

@@ -120,14 +120,14 @@ var applicationUpdateInputSchema = z4.record(z4.string(), z4.never());
 var applicationUpdateResponseSchema = z4.object({ state: applicationUpdateStateSchema });
 
 // ../contract/src/health.ts
-var runnerSchema = z5.enum(["claude", "codex", "opencode", "pi", "cursor"]);
+var runnerSchema = z5.enum(["claude", "codex", "opencode", "pi", "cursor", "omp"]);
 var repoInfoSchema = z5.object({
   root: z5.string(),
   branch: z5.string(),
   remote: z5.string().optional()
 });
 var backendCheckSchema = z5.object({
-  name: z5.enum(["claude", "codex", "opencode", "pi", "cursor", "gh", "git"]),
+  name: z5.enum(["claude", "codex", "opencode", "pi", "cursor", "omp", "gh", "git"]),
   available: z5.boolean(),
   version: z5.string().optional(),
   hint: z5.string().optional()
@@ -156,6 +156,14 @@ var capabilitiesSchema = z5.object({
    * REQUIRED for the same reason as `tokenMetrics` below: this server always sends it.
    */
   automations: z5.boolean(),
+  /**
+   * `true` means `CEZ_PREVIEW=1` opted this server into live preview (#781): the `cezar_preview_serve`
+   * tool is listed, its route answers, the preview WebSocket upgrades and the cockpit offers the
+   * pane. Off — the default — every one of those is absent.
+   *
+   * REQUIRED for the same reason as `tokenMetrics` below: this server always sends it.
+   */
+  preview: z5.boolean(),
   /**
    * `false` means `CEZ_HIDE_TOKEN_METRICS=1` asks the browser to omit token counts and monetary
    * cost (#481). The telemetry itself still rides in run/event payloads — this is presentation
@@ -232,7 +240,8 @@ var workspaceConfigResponseSchema = z6.object({
       codex: z6.string().optional(),
       opencode: z6.string().optional(),
       pi: z6.string().optional(),
-      cursor: z6.string().optional()
+      cursor: z6.string().optional(),
+      omp: z6.string().optional()
     }).optional()
   })
 });
@@ -253,7 +262,8 @@ var setWorkspaceConfigInputSchema = z6.object({
       codex: z6.string().trim().min(1).max(200).nullable().optional(),
       opencode: z6.string().trim().min(1).max(200).nullable().optional(),
       pi: z6.string().trim().min(1).max(200).nullable().optional(),
-      cursor: z6.string().trim().min(1).max(200).nullable().optional()
+      cursor: z6.string().trim().min(1).max(200).nullable().optional(),
+      omp: z6.string().trim().min(1).max(200).nullable().optional()
     }).optional()
   }).optional(),
   resources: z6.object({
@@ -274,7 +284,23 @@ var taskTableUiStateSchema = z6.looseObject({
   /** Explicit user choices only. Missing ids keep the registry-owned default. */
   expandedColumns: z6.record(z6.string(), z6.boolean()).optional()
 });
+var sidebarLimitsSchema = z6.object({
+  overall: z6.number().int().positive().nullable().optional(),
+  needsYou: z6.number().int().positive().nullable().optional(),
+  finished: z6.number().int().positive().nullable().optional(),
+  working: z6.number().int().positive().nullable().optional()
+});
+function normalizeSidebarLimits(value) {
+  const defaults = { overall: 10, needsYou: null, finished: null, working: null };
+  const input = value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+  for (const key of Object.keys(defaults)) {
+    const parsed = sidebarLimitsSchema.shape[key].safeParse(input[key]);
+    if (parsed.success && parsed.data !== void 0) defaults[key] = parsed.data;
+  }
+  return defaults;
+}
 var uiStateSchema = z6.looseObject({
+  sidebarLimits: sidebarLimitsSchema.optional(),
   /** What the last started run used. `null` is a VALUE, not an absence: it records a run that
    *  chose neither a skill nor a workflow (the plain built-in `quick-task`), which the composer
    *  can now express since the source picker grew an empty state. Absent still means "no
@@ -332,7 +358,8 @@ var workspaceUiStateSchema = z6.looseObject({
     codex: z6.string().optional(),
     opencode: z6.string().optional(),
     pi: z6.string().optional(),
-    cursor: z6.string().optional()
+    cursor: z6.string().optional(),
+    omp: z6.string().optional()
   }).optional(),
   /** Settings → Appearance, GLOBAL since step 3.5: accent + density describe the person at the
    *  keyboard, not a repo. */
@@ -366,7 +393,8 @@ var setWorkspaceUiStateInputSchema = z6.looseObject({
     codex: z6.string().min(1).max(128).optional(),
     opencode: z6.string().min(1).max(128).optional(),
     pi: z6.string().min(1).max(128).optional(),
-    cursor: z6.string().min(1).max(128).optional()
+    cursor: z6.string().min(1).max(128).optional(),
+    omp: z6.string().min(1).max(128).optional()
   }).optional(),
   importedSkills: z6.array(z6.string().min(1).max(200)).max(WORKSPACE_UI_STATE_MAX_KEYS).optional(),
   taskTable: taskTableUiStateSchema.extend({
@@ -387,8 +415,18 @@ var runnerModelsSchema = z6.object({
   codex: z6.string().optional(),
   opencode: z6.string().optional(),
   pi: z6.string().optional(),
-  cursor: z6.string().optional()
-});
+  cursor: z6.string().optional(),
+  omp: z6.string().optional()
+});
+var WORKTREE_SETUP_MAX_COMMANDS = 20;
+var WORKTREE_SETUP_MAX_COMMAND_LENGTH = 4e3;
+var WORKTREE_SETUP_DEFAULT_TIMEOUT_SECONDS = 900;
+var WORKTREE_SETUP_MAX_TIMEOUT_SECONDS = 7200;
+var worktreeSetupConfigSchema = z6.object({
+  commands: z6.array(z6.string().trim().min(1).max(WORKTREE_SETUP_MAX_COMMAND_LENGTH)).max(WORKTREE_SETUP_MAX_COMMANDS),
+  /** Per command. Absent = `WORKTREE_SETUP_DEFAULT_TIMEOUT_SECONDS`. */
+  timeoutSeconds: z6.number().int().min(1).max(WORKTREE_SETUP_MAX_TIMEOUT_SECONDS).optional()
+}).strict();
 var configResponseSchema = z6.object({
   baseBranch: z6.string().nullable(),
   defaultRunner: runnerSchema,
@@ -407,7 +445,12 @@ var configResponseSchema = z6.object({
   liveTitleUpdates: z6.boolean().nullable(),
   /** Optional review gate (#489): null = no config key, the `CEZ_REVIEW_GATE` env default (OFF)
    *  decides. */
-  reviewGate: z6.boolean().nullable()
+  reviewGate: z6.boolean().nullable(),
+  /** Worktree setup (#917): the commands that prepare a new task or worker worktree, with the
+   *  timeout filled in. null = no setup, or an invalid value (then `worktreeSetupIssue` says why). */
+  worktreeSetup: z6.object({ commands: z6.array(z6.string()), timeoutSeconds: z6.number() }).nullable(),
+  /** Why `config.json`'s `worktreeSetup` is invalid; null when it is valid or absent. */
+  worktreeSetupIssue: z6.string().nullable()
 });
 var setConfigResponseSchema = configResponseSchema;
 var setConfigInputSchema = z6.object({
@@ -419,7 +462,8 @@ var setConfigInputSchema = z6.object({
     codex: z6.string().trim().max(200).nullable().optional(),
     opencode: z6.string().trim().max(200).nullable().optional(),
     pi: z6.string().trim().max(200).nullable().optional(),
-    cursor: z6.string().trim().max(200).nullable().optional()
+    cursor: z6.string().trim().max(200).nullable().optional(),
+    omp: z6.string().trim().max(200).nullable().optional()
   }).optional(),
   maxParallel: z6.number().int().min(1).max(16).optional(),
   /** null or 0 clears the ceiling back to "no limit". */
@@ -429,7 +473,10 @@ var setConfigInputSchema = z6.object({
   /** null clears the key back to the env-default behavior. */
   liveTitleUpdates: z6.boolean().nullable().optional(),
   /** null clears the key back to the env-default behavior (OFF). */
-  reviewGate: z6.boolean().nullable().optional()
+  reviewGate: z6.boolean().nullable().optional(),
+  /** Worktree setup (#917). null or an empty command list deletes the key. Refused with 409 by a
+   *  hosted cockpit: these are commands the host runs. */
+  worktreeSetup: worktreeSetupConfigSchema.nullable().optional()
 });
 var skillsUpdateStatusSchema = z6.enum([
   "idle",
@@ -485,7 +532,7 @@ var providerConnectResponseSchema = z6.discriminatedUnion("opened", [
   z6.object({ opened: z6.literal(true), command: z6.string() }),
   z6.object({ opened: z6.literal(false), connected: z6.literal(true), command: z6.string() })
 ]);
-var modelDiscoveryRunnerSchema = z6.enum(["claude", "codex", "opencode", "pi", "cursor"]);
+var modelDiscoveryRunnerSchema = z6.enum(["claude", "codex", "opencode", "pi", "cursor", "omp"]);
 var MODEL_DISCOVERY_RUNNERS = modelDiscoveryRunnerSchema.options;
 function runnerDiscoversModels(runner) {
   return MODEL_DISCOVERY_RUNNERS.includes(runner);
@@ -579,12 +626,18 @@ var workerWaitSchema = z8.object({
   outcomes: z8.array(workerOutcomeSchema).max(32),
   wakeId: z8.uuid().optional()
 }).strict();
+var workerDestroyRetrySchema = z8.object({
+  attempts: z8.number().int().positive(),
+  nextAt: z8.iso.datetime(),
+  needsAttention: z8.literal(true).optional()
+}).strict();
 var workerDestroySchema = z8.object({
   requestedAt: z8.iso.datetime(),
   phase: z8.enum(["requested", "terminating", "cleaning", "complete", "incomplete"]),
   remaining: remainingSchema,
   error: errorSchema.optional()
 }).strict();
+var workerDestroyViewSchema = workerDestroySchema.extend({ retry: workerDestroyRetrySchema.optional() }).strict();
 var workerCreationReceiptSchema = z8.object({
   requestId: z8.uuid(),
   workerId: z8.uuid(),
@@ -592,7 +645,7 @@ var workerCreationReceiptSchema = z8.object({
   requestHash: requestHashSchema,
   deletion: z8.object({ phase: z8.enum(["pending", "complete"]), revision: z8.number().int().nonnegative(), resourceId: z8.uuid(), generation: z8.uuid() }).strict().optional()
 }).strict();
-var workerBackendSchema = z8.enum(["claude", "codex", "opencode", "pi", "cursor"]);
+var workerBackendSchema = z8.enum(["claude", "codex", "opencode", "pi", "cursor", "omp"]);
 var relativeInputPath = z8.string().min(1).max(4096).refine((path) => !/[\\\u0000-\u001f\u007f:]/.test(path) && !path.startsWith("/") && path.split("/").every((part) => part !== "" && part !== "." && part !== ".."));
 var workerContextReferenceSchema = z8.discriminatedUnion("kind", [
   z8.object({ kind: z8.literal("baseline-file"), path: relativeInputPath }).strict(),
@@ -674,10 +727,11 @@ var delegationStateSchema = z8.discriminatedUnion("role", [
     role: z8.literal("root"),
     conversation: conversationStateSchema.optional(),
     permissions: permissionsSchema,
-    receipts: z8.array(workerCreationReceiptSchema).max(32).refine((receipts) => new Set(receipts.map((receipt) => receipt.requestId)).size === receipts.length && new Set(receipts.map((receipt) => receipt.workerId)).size === receipts.length),
+    // #816: bounded by the creation ceiling (WORKER_CREATION_LIMIT), not by capacity.
+    receipts: z8.array(workerCreationReceiptSchema).max(1024).refine((receipts) => new Set(receipts.map((receipt) => receipt.requestId)).size === receipts.length && new Set(receipts.map((receipt) => receipt.workerId)).size === receipts.length),
     wait: workerWaitSchema.optional(),
     lastWait: workerWaitSchema.optional(),
-    results: z8.array(workerResultReferenceSchema).max(32).refine((results) => new Set(results.map((result) => result.workerId)).size === results.length).optional(),
+    results: z8.array(workerResultReferenceSchema).max(1024).refine((results) => new Set(results.map((result) => result.workerId)).size === results.length).optional(),
     finishRequestedAt: z8.iso.datetime().optional(),
     historyDeletion: z8.literal("pending").optional(),
     completion: z8.object({ phase: z8.enum(["waiting", "attention"]), waitId: z8.uuid().optional() }).strict().optional()
@@ -699,9 +753,15 @@ var delegationStateSchema = z8.discriminatedUnion("role", [
 ]);
 var runDelegationSummarySchema = z8.discriminatedUnion("role", [
   delegationStateSchema.options[0].pick({ role: true }).strip().extend({
-    wait: workerWaitSchema.pick({ phase: true, requestIds: true }).strip().optional()
+    // The awaited worker ids and which of them reported (ids only) keep a list's counted label,
+    // "waiting on 2 workers" (#617), now that lists read summaries instead of records (#817).
+    wait: workerWaitSchema.pick({ phase: true, requestIds: true, workerIds: true }).partial({ workerIds: true }).strip().extend({
+      outcomes: z8.array(workerOutcomeSchema.pick({ workerId: true }).strip()).max(32).optional()
+    }).optional()
   }),
-  delegationStateSchema.options[1].pick({ role: true }).strip().extend({
+  // `parentRunId` is the one worker field a list needs: the sidebar lights the parent's row for
+  // a worker URL, and `cez task list` hides workers by it (#817). Never paths or permissions.
+  delegationStateSchema.options[1].pick({ role: true, parentRunId: true }).strip().extend({
     wait: workerWaitSchema.pick({ phase: true, requestIds: true }).strip().optional()
   }),
   delegationStateSchema.options[2].strip()
@@ -714,9 +774,11 @@ var workerSpawnRequestSchema = z8.object({
   backend: workerBackendSchema.optional(),
   model: z8.string().trim().min(1).max(512).optional(),
   effort: effortFieldSchema,
-  /** Catalog workflow name (built-in quick-task or `.ai/cezar/workflows/*.yaml`, #451). Absent means quick-task. */
-  workflow: z8.string().trim().min(1).max(200).optional()
-}).strict().refine((request) => request.task.length + (request.context?.text?.length ?? 0) <= 1e5, { message: "Combined task and context exceed 100000 characters" });
+  /** Catalog workflow name (built-in quick-task or `.ai/cezar/workflows/*.yaml`, #451). Absent with no skill means quick-task. */
+  workflow: z8.string().trim().min(1).max(200).optional(),
+  /** Discovered skill to run as a one-step task, mutually exclusive with workflow (#778). */
+  skill: z8.string().trim().min(1).max(200).optional()
+}).strict().refine((request) => request.skill === void 0 || request.workflow === void 0, { message: "--skill and --workflow cannot be used together" }).refine((request) => request.task.length + (request.context?.text?.length ?? 0) <= 1e5, { message: "Combined task and context exceed 100000 characters" });
 var workerSteerRequestSchema = z8.object({
   text: z8.string().max(1e5).refine((text) => text.trim().length > 0)
 }).strict();
@@ -760,7 +822,7 @@ var workerInspectionSchema = z8.object({
   model: z8.string().max(512).optional(),
   inputs: z8.array(workerInputSchema).max(32).optional(),
   wait: workerWaitSchema.optional(),
-  destroy: workerDestroySchema.optional(),
+  destroy: workerDestroyViewSchema.optional(),
   outcome: workerOutcomeSchema.optional()
 });
 var workerDiffSchema = z8.object({
@@ -783,9 +845,25 @@ var workerDestroyResultSchema = z8.object({
   remaining: remainingSchema,
   error: errorSchema.optional()
 });
+var workerCapacitySchema = z8.object({
+  outstanding: z8.number().int().nonnegative(),
+  limit: z8.number().int().nonnegative(),
+  created: z8.number().int().nonnegative(),
+  creationLimit: z8.number().int().nonnegative()
+}).strict();
+var relatedRunTitleSchema = z8.object({
+  id: z8.string(),
+  title: z8.string(),
+  titleSummary: z8.string().optional(),
+  titleOrigin: z8.enum(["user", "auto", "marker"]).optional()
+});
 var runRelationshipsSchema = z8.object({
   parentRunId: z8.uuid().optional(),
-  workers: z8.array(workerInspectionSchema).max(32)
+  workers: z8.array(workerInspectionSchema).max(1024),
+  /** The parent's title for a worker, each worker's for a parent; absent when there is none. */
+  titles: z8.array(relatedRunTitleSchema).max(1025).optional(),
+  /** Present for a delegation root only. */
+  capacity: workerCapacitySchema.optional()
 });
 var delegationErrorResponseSchema = z8.object({
   code: z8.enum([
@@ -992,7 +1070,7 @@ var ciWaitReceiptSchema = ciPrIdentitySchema.extend({
 }).strict();
 
 // ../contract/src/runs.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // ../contract/src/github.ts
 import { z as z11 } from "zod";
@@ -1017,7 +1095,12 @@ var githubItemSchema = z11.object({
   checks: checksGlyphSchema.optional()
 });
 var githubItemResponseSchema = z11.discriminatedUnion("available", [
-  z11.object({ available: z11.literal(true), item: githubItemSchema.nullable() }),
+  z11.object({
+    available: z11.literal(true),
+    item: githubItemSchema.nullable(),
+    /** Label name → GitHub hex colour (without #), as in the list and search responses. */
+    labelColors: z11.record(z11.string(), z11.string()).optional()
+  }),
   z11.object({ available: z11.literal(false), reason: z11.string() })
 ]);
 var githubItemParamsSchema = z11.object({
@@ -1261,30 +1344,201 @@ var githubProjectsDataSchema = z11.discriminatedUnion("state", [
   })
 ]);
 
-// ../contract/src/workflows.ts
+// ../contract/src/preview.ts
 import { z as z12 } from "zod";
-var workflowStepDefSchema = z12.object({
-  id: z12.string().min(1),
-  name: z12.string().optional(),
+var previewServeRequestSchema = z12.object({
+  command: z12.string().min(1).max(1024),
+  port: z12.number().int().min(1).max(65535),
+  cwd: z12.string().optional(),
+  label: z12.string().min(1).max(48).optional(),
+  path: z12.string().startsWith("/").optional()
+});
+var previewResultCodeSchema = z12.enum([
+  "registered",
+  "replaced",
+  "invalid_input",
+  "cwd_outside_worktree",
+  "cezar_port",
+  "port_held",
+  "too_many",
+  "preview_disabled",
+  "headless",
+  "worktree_missing",
+  "unavailable"
+]);
+var previewServeResultSchema = z12.object({
+  ok: z12.boolean(),
+  code: previewResultCodeSchema,
+  message: z12.string(),
+  hint: z12.string()
+});
+var previewStopRequestSchema = z12.object({
+  port: z12.number().int().min(1).max(65535),
+  restart: z12.boolean().optional()
+}).strict();
+var previewStopResultSchema = z12.object({
+  ok: z12.boolean(),
+  code: z12.enum(["stopped", "restarted", "approval_required", "adopted", "not_registered", "port_held", "port_in_use", "invalid_input", "preview_disabled", "headless", "worktree_missing", "unavailable"]),
+  message: z12.string(),
+  hint: z12.string()
+});
+var previewServerSchema = z12.object({
+  port: z12.number().int().min(1).max(65535),
+  command: z12.string(),
+  cwd: z12.string().optional(),
+  label: z12.string(),
+  path: z12.string().optional(),
+  registeredAt: z12.iso.datetime(),
+  answeredAtRegistration: z12.boolean()
+});
+var previewServerStateSchema = z12.enum([
+  "registered",
+  "starting",
+  "up",
+  "stalled",
+  "exited",
+  "stopped",
+  "adopted",
+  "unavailable"
+]);
+var port = z12.number().int().min(1).max(65535);
+var clampViewport = (value) => Math.min(4e3, Math.max(100, Math.round(value)));
+var previewMouseTypeSchema = z12.enum(["mousePressed", "mouseReleased", "mouseMoved", "mouseWheel"]);
+var previewMouseButtonSchema = z12.enum(["left", "middle", "right", "none"]);
+var previewKeyTypeSchema = z12.enum(["keyDown", "rawKeyDown", "keyUp"]);
+var previewClientMessageSchema = z12.discriminatedUnion("t", [
+  /** Never spawns anything: a silent port answers with `needs-approval`. */
+  z12.object({
+    t: z12.literal("open"),
+    target: z12.union([z12.object({ port }), z12.object({ url: z12.string().min(1).max(2048) })])
+  }),
+  /** The owner's explicit approval; the only message that runs a registered command. */
+  z12.object({ t: z12.literal("run"), port }),
+  z12.object({ t: z12.literal("stop"), port }),
+  z12.object({ t: z12.literal("keepWaiting"), port }),
+  z12.object({
+    t: z12.literal("resize"),
+    w: z12.number().finite().transform(clampViewport),
+    h: z12.number().finite().transform(clampViewport)
+  }),
+  z12.object({
+    t: z12.literal("mouse"),
+    type: previewMouseTypeSchema,
+    x: z12.number().finite(),
+    y: z12.number().finite(),
+    button: previewMouseButtonSchema.optional(),
+    buttons: z12.number().optional(),
+    clickCount: z12.number().optional(),
+    deltaX: z12.number().optional(),
+    deltaY: z12.number().optional(),
+    modifiers: z12.number().optional()
+  }),
+  z12.object({
+    t: z12.literal("key"),
+    type: previewKeyTypeSchema,
+    key: z12.string().optional(),
+    code: z12.string().optional(),
+    text: z12.string().optional(),
+    modifiers: z12.number().optional(),
+    vk: z12.number().optional(),
+    commands: z12.array(z12.string()).optional()
+  }),
+  z12.object({ t: z12.literal("insertText"), text: z12.string() }),
+  z12.object({ t: z12.literal("nav"), url: z12.string().min(1).max(2048) }),
+  z12.object({ t: z12.literal("back") }),
+  z12.object({ t: z12.literal("forward") }),
+  z12.object({ t: z12.literal("reload"), ignoreCache: z12.boolean().optional() }),
+  z12.object({ t: z12.literal("dialogResult"), accept: z12.boolean(), text: z12.string().optional() }),
+  z12.object({ t: z12.literal("ack") }),
+  z12.object({ t: z12.literal("ping"), ts: z12.number() }),
+  z12.object({ t: z12.literal("download") }),
+  z12.object({ t: z12.literal("cancelDownload") }),
+  z12.object({ t: z12.literal("retryBrowser") })
+]);
+var previewStateMessageSchema = z12.discriminatedUnion("stage", [
+  z12.object({ t: z12.literal("state"), stage: z12.literal("chromium-missing"), installCommand: z12.string(), canDownload: z12.boolean() }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("downloading"), received: z12.number(), total: z12.number() }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("download-failed"), error: z12.string(), installCommand: z12.string() }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("sandbox-failed"), stderrTail: z12.string() }),
+  z12.object({
+    t: z12.literal("state"),
+    stage: z12.literal("browser-exited"),
+    signal: z12.string().optional(),
+    stderrTail: z12.string(),
+    serverUp: z12.boolean()
+  }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("needs-approval"), server: previewServerSchema, wasRunning: z12.boolean() }),
+  /** Another task's cezar-owned server holds the port: never adopted, never spawned onto. Its title only, never its path. */
+  z12.object({ t: z12.literal("state"), stage: z12.literal("port-held"), server: previewServerSchema, ownerTitle: z12.string() }),
+  z12.object({
+    t: z12.literal("state"),
+    stage: z12.literal("server-starting"),
+    server: previewServerSchema,
+    attempt: z12.number().int(),
+    startedAt: z12.iso.datetime(),
+    /** The newest lines the command printed, oldest first; empty before it prints anything. */
+    logTail: z12.array(z12.string())
+  }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("server-stalled"), server: previewServerSchema, logTail: z12.string() }),
+  z12.object({
+    t: z12.literal("state"),
+    stage: z12.literal("server-exited"),
+    server: previewServerSchema,
+    /** `null` when a signal ended the process. */
+    exitCode: z12.number().int().nullable(),
+    logTail: z12.string()
+  }),
+  z12.object({
+    t: z12.literal("state"),
+    stage: z12.literal("server-stopped"),
+    server: previewServerSchema,
+    reason: z12.enum(["user", "idle"]),
+    lastUrl: z12.string()
+  }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("worktree-removed"), server: previewServerSchema.optional() }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("loading"), step: z12.enum(["browser", "page", "frame"]) }),
+  z12.object({ t: z12.literal("state"), stage: z12.literal("streaming"), adopted: z12.boolean() })
+]);
+var previewServerMessageSchema = z12.discriminatedUnion("t", [
+  previewStateMessageSchema,
+  z12.object({ t: z12.literal("url"), url: z12.string() }),
+  z12.object({ t: z12.literal("cursor"), cursor: z12.string() }),
+  z12.object({
+    t: z12.literal("dialog"),
+    type: z12.enum(["alert", "confirm", "prompt", "beforeunload"]),
+    message: z12.string(),
+    defaultPrompt: z12.string().optional(),
+    origin: z12.string()
+  }),
+  z12.object({ t: z12.literal("replaced"), by: z12.string() }),
+  z12.object({ t: z12.literal("pong"), ts: z12.number() }),
+  z12.object({ t: z12.literal("downloadProgress"), received: z12.number(), total: z12.number() })
+]);
+
+// ../contract/src/workflows.ts
+import { z as z13 } from "zod";
+var workflowStepDefSchema = z13.object({
+  id: z13.string().min(1),
+  name: z13.string().optional(),
   // agent step
-  prompt: z12.string().optional(),
-  skill: z12.string().optional(),
-  model: z12.string().optional(),
-  effort: z12.string().max(32).optional(),
+  prompt: z13.string().optional(),
+  skill: z13.string().optional(),
+  model: z13.string().optional(),
+  effort: z13.string().max(32).optional(),
   /** Authored agent-step wall-clock limit in ms. Omitted or 0 means no limit.
    *  Bound to Node's timer range so a larger value cannot become a 1ms kill. */
-  timeoutMs: z12.number().int().min(0).max(2147483647).optional(),
+  timeoutMs: z13.number().int().min(0).max(2147483647).optional(),
   /** Per-step agent backend override (falls back to the task / config default). */
   runner: runnerSchema.optional(),
   /** Agent account id for this step (spec 2026-07-29-agent-profiles); resolved per step for owned workers (#452). */
-  agentProfile: z12.string().min(1).max(64).optional(),
-  allowedTools: z12.array(z12.string()).optional(),
-  bashAllowlist: z12.array(z12.string()).optional(),
+  agentProfile: z13.string().min(1).max(64).optional(),
+  allowedTools: z13.array(z13.string()).optional(),
+  bashAllowlist: z13.array(z13.string()).optional(),
   // check step
-  command: z12.string().optional(),
-  onFail: z12.object({
-    retry: z12.string().min(1),
-    max: z12.number().int().positive().default(2)
+  command: z13.string().optional(),
+  onFail: z13.object({
+    retry: z13.string().min(1),
+    max: z13.number().int().positive().default(2)
   }).optional()
 }).refine((s) => Boolean(s.command) !== Boolean(s.prompt ?? s.skill), {
   message: "a step is either an agent step (prompt/skill) or a check step (command), not both"
@@ -1292,13 +1546,13 @@ var workflowStepDefSchema = z12.object({
   message: "timeoutMs applies only to agent steps",
   path: ["timeoutMs"]
 });
-var workflowDefSchema = z12.object({
-  name: z12.string(),
-  description: z12.string().optional(),
-  steps: z12.array(workflowStepDefSchema),
-  source: z12.enum(["built-in", "file"]),
+var workflowDefSchema = z13.object({
+  name: z13.string(),
+  description: z13.string().optional(),
+  steps: z13.array(workflowStepDefSchema),
+  source: z13.enum(["built-in", "file"]),
   /** Absent on built-ins — which is exactly what makes them undeletable. */
-  path: z12.string().optional()
+  path: z13.string().optional()
 });
 function providersRequiredByWorkflow(workflow, fallback) {
   const required = /* @__PURE__ */ new Set();
@@ -1307,46 +1561,46 @@ function providersRequiredByWorkflow(workflow, fallback) {
   }
   return runnerSchema.options.filter((provider) => required.has(provider));
 }
-var workflowLoadIssueSchema = z12.object({
-  path: z12.string(),
-  message: z12.string()
-});
-var workflowsResponseSchema = z12.object({
-  workflows: z12.array(workflowDefSchema),
-  issues: z12.array(workflowLoadIssueSchema)
-});
-var saveWorkflowInputSchema = z12.object({
-  name: z12.string().trim().min(1).max(80),
-  description: z12.string().max(2e3, "must be at most 2000 characters").optional(),
-  steps: z12.array(workflowStepDefSchema).min(1).max(8).optional(),
-  skills: z12.array(z12.string().trim().min(1)).min(1).max(8).optional(),
-  overwrite: z12.boolean().optional()
+var workflowLoadIssueSchema = z13.object({
+  path: z13.string(),
+  message: z13.string()
+});
+var workflowsResponseSchema = z13.object({
+  workflows: z13.array(workflowDefSchema),
+  issues: z13.array(workflowLoadIssueSchema)
+});
+var saveWorkflowInputSchema = z13.object({
+  name: z13.string().trim().min(1).max(80),
+  description: z13.string().max(2e3, "must be at most 2000 characters").optional(),
+  steps: z13.array(workflowStepDefSchema).min(1).max(8).optional(),
+  skills: z13.array(z13.string().trim().min(1)).min(1).max(8).optional(),
+  overwrite: z13.boolean().optional()
 }).refine((b) => Boolean(b.steps) !== Boolean(b.skills), {
   message: 'provide either "steps" or "skills", not both'
 });
-var saveWorkflowResponseSchema = z12.object({
-  path: z12.string(),
-  name: z12.string()
+var saveWorkflowResponseSchema = z13.object({
+  path: z13.string(),
+  name: z13.string()
 });
-var parsedWorkflowSchema = z12.object({
-  name: z12.string(),
-  description: z12.string().optional(),
-  steps: z12.array(workflowStepDefSchema)
+var parsedWorkflowSchema = z13.object({
+  name: z13.string(),
+  description: z13.string().optional(),
+  steps: z13.array(workflowStepDefSchema)
 });
-var deleteWorkflowResponseSchema = z12.object({
-  ok: z12.literal(true),
-  path: z12.string()
+var deleteWorkflowResponseSchema = z13.object({
+  ok: z13.literal(true),
+  path: z13.string()
 });
-var planResponseSchema = z12.object({
+var planResponseSchema = z13.object({
   /** The kebab-case workflow title the planner proposed. Absent on the degraded fallback. */
-  name: z12.string().optional(),
-  steps: z12.array(workflowStepDefSchema),
-  rationale: z12.string(),
-  fallback: z12.boolean()
+  name: z13.string().optional(),
+  steps: z13.array(workflowStepDefSchema),
+  rationale: z13.string(),
+  fallback: z13.boolean()
 });
 
 // ../contract/src/runs.ts
-var runStatusSchema = z13.enum([
+var runStatusSchema = z14.enum([
   "queued",
   "running",
   "waiting",
@@ -1355,8 +1609,8 @@ var runStatusSchema = z13.enum([
   "failed",
   "cancelled"
 ]);
-var runActivitySchema = z13.enum(["monitoring"]);
-var stepStatusSchema = z13.enum([
+var runActivitySchema = z14.enum(["monitoring"]);
+var stepStatusSchema = z14.enum([
   "pending",
   "running",
   "waiting",
@@ -1366,16 +1620,16 @@ var stepStatusSchema = z13.enum([
   "cancelled",
   "skipped"
 ]);
-var usageCounterSchema = z13.number().finite().nonnegative();
-var stepStateSchema = z13.object({
-  id: z13.string(),
-  name: z13.string(),
-  kind: z13.enum(["agent", "check"]),
+var usageCounterSchema = z14.number().finite().nonnegative();
+var stepStateSchema = z14.object({
+  id: z14.string(),
+  name: z14.string(),
+  kind: z14.enum(["agent", "check"]),
   status: stepStatusSchema,
-  iterations: z13.number(),
+  iterations: z14.number(),
   /** Durable count of onFail retry loops consumed by this check. */
-  retriesUsed: z13.number().int().nonnegative().optional(),
-  tokensUsed: z13.number(),
+  retriesUsed: z14.number().int().nonnegative().optional(),
+  tokensUsed: z14.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
   usageInvocationsStarted: usageCounterSchema.optional(),
@@ -1383,103 +1637,113 @@ var stepStateSchema = z13.object({
   usageTurnsStarted: usageCounterSchema.optional(),
   usageTurnsRecorded: usageCounterSchema.optional(),
   usageInvocationEpoch: usageCounterSchema.optional(),
-  startedAt: z13.string().optional(),
-  finishedAt: z13.string().optional(),
-  error: z13.string().optional(),
+  startedAt: z14.string().optional(),
+  finishedAt: z14.string().optional(),
+  error: z14.string().optional(),
   /** Latest agent session id — `claude --resume <id>` and friends. */
-  sessionId: z13.string().optional(),
+  sessionId: z14.string().optional(),
   /** Backend that owns `sessionId`; absent on records written before backend affinity. */
   backend: runnerSchema.optional(),
   /** Agent account (spec 2026-07-29-agent-profiles) that owns `sessionId` — `default`, or a
    *  stored profile id. The two are a PAIR: a session id only resolves inside the config dir
    *  that created it, so resume and Continue read this rather than the project's current
    *  selection. Absent on records written before accounts existed. */
-  profileId: z13.string().optional(),
-  costUsd: z13.number().optional(),
+  profileId: z14.string().optional(),
+  costUsd: z14.number().optional(),
   /** Explicit provenance for engine-generated continuation steps. */
-  synthetic: z13.literal("continuation").optional()
+  synthetic: z14.literal("continuation").optional()
 });
-var diffStatSchema = z13.object({
-  adds: z13.number(),
-  dels: z13.number(),
-  files: z13.number(),
+var diffStatSchema = z14.object({
+  adds: z14.number(),
+  dels: z14.number(),
+  files: z14.number(),
   /** Additive since #751, and present ONLY when true: the numbers were measured against a
    *  branch the agent checked out into the task's worktree, as the run found it, because the
    *  worktree's HEAD had been repointed off the task's own branch (every review/QA run does
    *  this) and the merge-base anchor would otherwise have reported that branch's entire diff
    *  as this task's. Absent on every normal run and on every record written before #751 — a
    *  consumer that ignores it sees exactly the old shape. */
-  repointed: z13.boolean().optional()
+  repointed: z14.boolean().optional()
 });
-var queuedMessageSchema = z13.object({
-  id: z13.string(),
-  text: z13.string(),
+var queuedMessageSchema = z14.object({
+  id: z14.string(),
+  text: z14.string(),
   /** `/api/v1/runs/:id/images/…` URLs — attachments are persisted, never inlined. Images and
    *  files share this one list; read `isImageAttachmentName` on the file name to tell them apart. */
-  images: z13.array(z13.string()).optional(),
-  createdAt: z13.string()
+  images: z14.array(z14.string()).optional(),
+  createdAt: z14.string()
 });
 var continuationMessageSchema = queuedMessageSchema.extend({
-  origin: z13.enum(["human", "lifecycle"]).optional(),
+  origin: z14.enum(["human", "lifecycle"]).optional(),
   /** An attributed parent message used as the opening prompt, never a human answer. */
-  agentInputId: z13.uuid().optional()
+  agentInputId: z14.uuid().optional()
 });
-var processUsageSchema = z13.object({
+var processUsageSchema = z14.object({
   /** Sum of `%cpu` across the tree — can exceed 100 on multi-core work. */
-  cpuPct: z13.number(),
-  rssBytes: z13.number(),
-  procCount: z13.number()
-});
-var runWebhookOutcomeSchema = z13.object({
-  lastDeliveredAt: z13.string().optional(),
-  lastError: z13.string().max(512).optional()
-});
-var runRecordSchema = z13.object({
-  id: z13.string(),
-  title: z13.string(),
+  cpuPct: z14.number(),
+  rssBytes: z14.number(),
+  procCount: z14.number()
+});
+var runWebhookOutcomeSchema = z14.object({
+  lastDeliveredAt: z14.string().optional(),
+  lastError: z14.string().max(512).optional()
+});
+var runWorktreeSetupSchema = z14.object({
+  status: z14.enum(["running", "done", "failed"]),
+  startedAt: z14.string(),
+  finishedAt: z14.string().optional(),
+  durationMs: z14.number().optional(),
+  /** One line: "`npm ci` exited 1", "`npm ci` timed out after 900s", "invalid config: …". */
+  error: z14.string().optional()
+});
+var runRecordSchema = z14.object({
+  id: z14.string(),
+  title: z14.string(),
   /** Display title (#389): auto-derived from the first agent turn, or the user's inline edit
    *  (`PATCH /runs/:id` sets it together with `title`). Show `titleSummary ?? title`. */
-  titleSummary: z13.string().optional(),
+  titleSummary: z14.string().optional(),
   /** Refreshed on every turn-end; absent until the first turn ends (and on worktree-less runs). */
   diffStat: diffStatSchema.optional(),
-  workflow: z13.string(),
-  task: z13.string(),
+  workflow: z14.string(),
+  task: z14.string(),
   /** Prompt messages stacked onto the run while it waited for a free agent slot (#472). Folded
    *  into the prompt at dequeue — never delivered as their own turns. Absent on pre-#472 runs. */
-  queuedMessages: z13.array(queuedMessageSchema).optional(),
+  queuedMessages: z14.array(queuedMessageSchema).optional(),
   /** Stop was accepted; execution termination is still pending. */
-  stopping: z13.boolean().optional(),
+  stopping: z14.boolean().optional(),
   /** Opening Continue message, retained until its first completed turn for crash recovery. */
   continuationMessage: continuationMessageSchema.optional(),
   /** The last turn carried a malformed explicit structured question. */
-  invalidAsk: z13.boolean().optional(),
+  invalidAsk: z14.boolean().optional(),
   /** Owned-run authority; absence is legacy, invalid is explicitly quarantined. */
   delegation: delegationStateSchema.optional(),
   /** Durable non-human input, kept separate from human prompt/answer queues. */
-  agentInputs: z13.array(agentInputSchema).optional(),
+  agentInputs: z14.array(agentInputSchema).optional(),
   ciWait: ciWaitSchema.optional(),
   lastCiWait: ciWaitSchema.optional(),
   /** Retained recovery observation when previous CI metadata cannot be trusted. */
-  lastCiWaitError: z13.string().max(256).optional(),
+  lastCiWaitError: z14.string().max(256).optional(),
+  /** Dev servers the agent registered with `cezar_preview_serve` (#781). Salvaged per entry on load. */
+  previewServers: z14.array(previewServerSchema).optional(),
   /** URLs of images and document attachments on the initial task prompt; branch on isImageAttachmentName. */
-  taskImages: z13.array(z13.string()).optional(),
-  model: z13.string().optional(),
+  taskImages: z14.array(z14.string()).optional(),
+  model: z14.string().optional(),
   /** Reasoning-effort pin (#45). Canonical `low`/`medium`/`high`/`xhigh`/`max`.
    *  Absent = harness default. Additive: pre-#45 records omit it and still parse. */
-  effort: z13.string().max(32).optional(),
+  effort: z14.string().max(32).optional(),
   /** Normalized provider/model identity used for attribution and reproducible replay. */
-  modelIdentity: z13.string().optional(),
+  modelIdentity: z14.string().optional(),
   runner: runnerSchema.optional(),
   /** The composer's per-task agent account (spec 2026-07-29-agent-profiles), applying to steps
    *  on `runner`. Absent = the run follows the project's own selection. */
-  agentProfile: z13.string().optional(),
+  agentProfile: z14.string().optional(),
   /** Echo of the extra system prompt the run used (POST override or config default). */
-  systemPrompt: z13.string().optional(),
+  systemPrompt: z14.string().optional(),
   /** false when the run deliberately disabled follow-up todo generation. Absent means enabled. */
-  generateFollowups: z13.boolean().optional(),
+  generateFollowups: z14.boolean().optional(),
   /** Autonomous mode (#autonomous): the run never parks at `waiting` or the terminal `review`
    *  gate. Absent = falsy = not autonomous. */
-  autonomous: z13.boolean().optional(),
+  autonomous: z14.boolean().optional(),
   /**
    * Provenance for a task a project GitHub automation launched (#694). Absent on every ordinary
    * run, which is what makes it additive — the cockpit shows the "from automation" link only when
@@ -1489,17 +1753,34 @@ var runRecordSchema = z13.object({
    * launching definition matched, recorded on the run for the audit trail, and `src/runs/store.ts`
    * persists it as free text so an older cezar can still read a record written by a newer one.
    */
-  automation: z13.object({
-    automationId: z13.string(),
-    automationRevision: z13.number(),
-    receiptId: z13.string(),
-    event: z13.string(),
-    githubUrl: z13.string()
+  automation: z14.object({
+    automationId: z14.string(),
+    automationRevision: z14.number(),
+    receiptId: z14.string(),
+    event: z14.string(),
+    githubUrl: z14.string()
   }).optional(),
+  /**
+   * Provenance for a task a SCHEDULED automation launched. A separate optional key rather than a
+   * loosened `automation`: `runs.json` is parsed as one array, so a downgraded cezar meeting a
+   * record without `githubUrl` would drop every run, whereas an unknown key it simply strips.
+   */
+  automationTrigger: z14.object({
+    automationId: z14.string(),
+    automationRevision: z14.number(),
+    receiptId: z14.string(),
+    trigger: z14.enum(["schedule", "catch-up", "manual"]),
+    /** The scheduled instant (UTC ISO); for `manual`, the launch time. */
+    occurrenceAt: z14.string()
+  }).optional(),
+  /** A pending worker destroy's automatic retry state (hearsay-tools/cezarion#879). Here, not in
+   *  the strict worker `delegation`, so an older cezar strips it instead of quarantining the worker,
+   *  and keeps it across its own writes. The API shows it as the worker's `destroy.retry`. */
+  destroyRetry: workerDestroyRetrySchema.optional(),
   /** Task webhook opt-in (#589): the project's webhook receives this run's status changes.
    *  Absent = off. Changes after start through `POST /runs/:id/notify`, which is why it is not
    *  part of the idempotent-start hash. */
-  notify: z13.boolean().optional(),
+  notify: z14.boolean().optional(),
   /** The last webhook delivery's outcome (#589). Absent until a delivery was attempted. */
   webhook: runWebhookOutcomeSchema.optional(),
   status: runStatusSchema,
@@ -1508,88 +1789,90 @@ var runRecordSchema = z13.object({
   activity: runActivitySchema.optional(),
   /** Derived from valid human questions and matching delivery receipts in durable history.
    * List attention only; never authorization to deliver an answer or wake a worker. */
-  hasPendingHumanAsk: z13.boolean().optional(),
+  hasPendingHumanAsk: z14.boolean().optional(),
   /** Exact ISO-8601 deadline for the next automatic monitoring check. */
-  monitoringWakeAt: z13.string().optional(),
+  monitoringWakeAt: z14.string().optional(),
   /** The current live monitoring epoch exhausted its 40 automatic checks. */
-  monitoringWakeCapReached: z13.boolean().optional(),
+  monitoringWakeCapReached: z14.boolean().optional(),
   /** Exact ISO-8601 instant this run resumes itself after a provider usage limit stopped it
    *  (spec 2026-08-03-auto-resume-after-usage-limit). Present only on a `failed` run with a
    *  pending automatic resume — its absence is what "no resume is scheduled" looks like. */
-  autoResumeAt: z13.string().optional(),
+  autoResumeAt: z14.string().optional(),
   /** Consecutive automatic resumes since the last human turn, against the safety cap. */
-  autoResumeAttempts: z13.number().optional(),
-  createdAt: z13.string(),
-  startedAt: z13.string().optional(),
-  finishedAt: z13.string().optional(),
-  tokensUsed: z13.number(),
+  autoResumeAttempts: z14.number().optional(),
+  createdAt: z14.string(),
+  startedAt: z14.string().optional(),
+  finishedAt: z14.string().optional(),
+  tokensUsed: z14.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
-  costUsd: z13.number().optional(),
-  pullRequestUrl: z13.string().optional(),
+  costUsd: z14.number().optional(),
+  pullRequestUrl: z14.string().optional(),
   /** The PR this task is ABOUT (#407) — auto-discovered from conversation references. Display
    *  tier only: `pullRequestUrl` (the PR this task CREATED) wins, and the action gates ignore it. */
-  referencedPullRequestUrl: z13.string().optional(),
+  referencedPullRequestUrl: z14.string().optional(),
   /** The PR/issue number this task is ABOUT (task auto-naming spec) — display tier only. */
-  prNumber: z13.number().optional(),
-  issueNumber: z13.number().optional(),
+  prNumber: z14.number().optional(),
+  issueNumber: z14.number().optional(),
   /** Server-side provenance: referenced-issue discovery currently owns `issueNumber`. */
-  referencedIssueNumberSeeded: z13.boolean().optional(),
+  referencedIssueNumberSeeded: z14.boolean().optional(),
   /** 'user' = renamed via PATCH, never auto-overwritten; 'marker' = agent-declared via
    *  CEZ:TITLE (spec 2026-07-18-task-ref-markers); 'auto' = namer-owned. */
-  titleOrigin: z13.enum(["user", "auto", "marker"]).optional(),
+  titleOrigin: z14.enum(["user", "auto", "marker"]).optional(),
   /** References the agent declared via CEZ:PR/CEZ:ISSUE markers — authoritative over the namer
    *  for the matching kind. */
-  markerRefs: z13.object({ pr: z13.number().optional(), issue: z13.number().optional() }).optional(),
+  markerRefs: z14.object({ pr: z14.number().optional(), issue: z14.number().optional() }).optional(),
   /** The referenced tier's working set (distinct PR URLs spotted, capped server-side). */
-  referencedPrCandidates: z13.array(z13.string()).optional(),
+  referencedPrCandidates: z14.array(z14.string()).optional(),
   /** The issue this task is ABOUT (spec 2026-07-21-report-ref-discovery). Display-only. */
-  referencedIssueUrl: z13.string().optional(),
+  referencedIssueUrl: z14.string().optional(),
   /** The referenced-issue working set, persisted like `referencedPrCandidates`. Capped. */
-  referencedIssueCandidates: z13.array(z13.string()).optional(),
+  referencedIssueCandidates: z14.array(z14.string()).optional(),
   /** Explicit execution policy. `false` means the run intentionally uses the repo root;
    *  absent on older runs and for the default isolated-worktree mode. */
-  worktree: z13.literal(false).optional(),
+  worktree: z14.literal(false).optional(),
   /** Absent for in-place runs and after an isolated worktree is removed. */
-  worktreePath: z13.string().optional(),
-  branch: z13.string().optional(),
+  worktreePath: z14.string().optional(),
+  branch: z14.string().optional(),
   /** Stable baseline for session git views: a worktree's fork ref, or an in-place run's starting commit. */
-  baseBranch: z13.string().optional(),
+  baseBranch: z14.string().optional(),
   /** Set when count-based retention (#483) reclaimed the worktree DIRECTORY (the branch is
    *  kept): the dir is gone but recoverable. */
-  worktreeReclaimedAt: z13.string().optional(),
+  worktreeReclaimedAt: z14.string().optional(),
+  /** The worktree setup this run's isolated worktree got (#917). Absent when none ran. */
+  worktreeSetup: runWorktreeSetupSchema.optional(),
   /** Parallel variants (spec 010): runs sharing a groupId are one group. */
-  groupId: z13.string().optional(),
+  groupId: z14.string().optional(),
   /** Variant letter within the group — 'A' | 'B' | 'C'. */
-  variant: z13.string().optional(),
+  variant: z14.string().optional(),
   /** Idempotent start (#504): the caller's request id and the hash of the start payload it
    *  named (`src/runs/client-request.ts`). Absent on every run started without one. */
-  clientRequestId: z13.string().optional(),
-  clientRequestHash: z13.string().optional(),
-  peakRssBytes: z13.number().optional(),
-  peakProcCount: z13.number().optional(),
-  archived: z13.boolean(),
-  archivedAt: z13.string().optional(),
+  clientRequestId: z14.string().optional(),
+  clientRequestHash: z14.string().optional(),
+  peakRssBytes: z14.number().optional(),
+  peakProcCount: z14.number().optional(),
+  archived: z14.boolean(),
+  archivedAt: z14.string().optional(),
   /** Pinned to the top of this project's task list (#935) — the `Pinned` group above
    *  `Needs you`. Optional, unlike `archived`: absent IS "not pinned", which is what every
    *  record written before this carries, and the store never writes `false`. Archiving
    *  clears it, because archiving is how a user resigns from a task. */
-  pinned: z13.boolean().optional(),
+  pinned: z14.boolean().optional(),
   /** When the pin was set. Deliberately WRITE-ONLY today, like the `archivedAt` above it:
    *  ordering inside `Pinned` uses the ordinary status/recency rules, so nothing reads this
    *  yet. It is here because a field on a protected surface is far cheaper to add now than to
    *  add later — "pinned oldest first" and "unpin what you pinned a month ago" both need it,
    *  and neither can be reconstructed after the fact. */
-  pinnedAt: z13.string().optional(),
+  pinnedAt: z14.string().optional(),
   /** Read receipt (#unread-done-items): ISO time the cockpit last opened this run's
    *  thread. A finished (`done`/`failed`) run reads as *unread* until seen since it
    *  finished — see `isUnread()` in the cockpit's `lib/read-state.ts`. Absent on old
    *  runs, on any run not yet opened, and on one deliberately put back to unread via
    *  `POST /runs/:id/unread` (#775) — all three count as unread. */
-  seenAt: z13.string().optional(),
-  currentStepId: z13.string().optional(),
-  error: z13.string().optional(),
-  steps: z13.array(stepStateSchema),
+  seenAt: z14.string().optional(),
+  currentStepId: z14.string().optional(),
+  error: z14.string().optional(),
+  steps: z14.array(stepStateSchema),
   /**
    * The persisted workflow definition, so a `queued` run survives a restart — including the ad-hoc
    * "(planned)" chains that exist nowhere else.
@@ -1607,48 +1890,45 @@ var runRecordSchema = z13.object({
 var apiRunSchema = runRecordSchema.extend({
   /** Read-only GET /runs/:id verdict: null permits Finish, a string explains refusal.
    * Absent on lists, stored records and mutation responses; absence is not permission. */
-  finishBlocked: z13.string().nullable().optional(),
+  finishBlocked: z14.string().nullable().optional(),
   /** Server-resolved Cursor CLI command, including the configured executable. Never persisted. */
-  cliResumeCommand: z13.string().optional(),
+  cliResumeCommand: z14.string().optional(),
   usage: processUsageSchema.optional()
 });
-var runIndexEntrySchema = z13.object({
-  /** The registered project this run belongs to. Joins against `GET /projects`. */
-  projectId: z13.string(),
-  id: z13.string(),
-  title: z13.string(),
-  titleSummary: z13.string().optional(),
-  titleOrigin: z13.enum(["user", "auto", "marker"]).optional(),
+var runSummarySchema = z14.object({
+  id: z14.string(),
+  title: z14.string(),
+  titleSummary: z14.string().optional(),
+  titleOrigin: z14.enum(["user", "auto", "marker"]).optional(),
   status: runStatusSchema,
   activity: runActivitySchema.optional(),
   hasPendingHumanAsk: runRecordSchema.shape.hasPendingHumanAsk,
   /** Only the relationship role and wait phase used by list attention. */
   delegation: runDelegationSummarySchema.optional(),
-  createdAt: z13.string(),
-  finishedAt: z13.string().optional(),
+  createdAt: z14.string(),
+  finishedAt: z14.string().optional(),
   /** With `status`/`finishedAt`/`archived`, the four inputs `isUnread` reads — what lets the
    *  palette lead with "finished while you weren't looking" across every project, not just the
    *  one you happen to be standing in. */
-  seenAt: z13.string().optional(),
+  seenAt: z14.string().optional(),
   /** Always present, like `RunRecord.archived`: absent would read as "not archived", and the
    *  unread rule treats archiving as a stronger "done with this" than reading. */
-  archived: z13.boolean(),
+  archived: z14.boolean(),
   /** A run parked by a provider usage limit is `failed` on the record with a resume booked
    *  (spec 2026-08-03-auto-resume-after-usage-limit). Both `deriveAttention` and `isUnread` read
    *  it, so without it here a cross-project row would show a red "failed" dot and land in
    *  Recently finished for work that is simply waiting for its appointment. */
-  autoResumeAt: z13.string().optional(),
+  autoResumeAt: z14.string().optional(),
   /** The workflow the run executes — the global Tasks page shows it in a column and groups by
-   *  it. Always present on the record (`RunRecord.workflow`), so required here; the display
-   *  refinement `workflowLabel` applies needs `steps[]`, which this row deliberately omits, so
-   *  a `(planned)` chain reads as itself here rather than as its first agent's name. */
-  workflow: z13.string(),
+   *  it. Always present on the record (`RunRecord.workflow`), so required here. The display
+   *  name, which reads a `(planned)` chain as its first agent's name, is `workflowLabel` below. */
+  workflow: z14.string(),
   /** The task's branch, when it has one — a column on the global page, and the one field that
    *  makes a cross-project row identifiable at a glance without opening it. */
-  branch: z13.string().optional(),
+  branch: z14.string().optional(),
   /** When the agent actually started, as opposed to when the task was created. The global page's
    *  age column prefers it and falls back to `createdAt`, exactly as the per-project table does. */
-  startedAt: z13.string().optional(),
+  startedAt: z14.string().optional(),
   /**
    * The six fields `taskReference()` (`web/src/lib/tasks-table.ts`) reads to decide a task's PR
    * or issue chip. Carried verbatim rather than pre-resolved into a `{kind, number, url}` on the
@@ -1660,20 +1940,20 @@ var runIndexEntrySchema = z13.object({
    * Six scalars is still the slim row this schema exists to keep: `steps[]` and `workflowDef`,
    * the expensive half, stay off it.
    */
-  pullRequestUrl: z13.string().optional(),
-  referencedPullRequestUrl: z13.string().optional(),
-  prNumber: z13.number().optional(),
-  issueNumber: z13.number().optional(),
-  referencedIssueUrl: z13.string().optional(),
-  markerRefs: z13.object({ pr: z13.number().optional(), issue: z13.number().optional() }).optional(),
+  pullRequestUrl: z14.string().optional(),
+  referencedPullRequestUrl: z14.string().optional(),
+  prNumber: z14.number().optional(),
+  issueNumber: z14.number().optional(),
+  referencedIssueUrl: z14.string().optional(),
+  markerRefs: z14.object({ pr: z14.number().optional(), issue: z14.number().optional() }).optional(),
   /** What the run has cost so far. Absent means nothing was recorded, which is NOT `$0` — the
    *  cockpit prints an em dash rather than claiming a measurement that never happened. */
-  costUsd: z13.number().optional(),
+  costUsd: z14.number().optional(),
   /** The persisted high-water marks a FINISHED run leaves behind. `usage` below stops existing
    *  the moment the process tree does, so without these a finished row could say nothing at all
    *  about what it took to run. */
-  peakRssBytes: z13.number().optional(),
-  peakProcCount: z13.number().optional(),
+  peakRssBytes: z14.number().optional(),
+  peakProcCount: z14.number().optional(),
   /**
    * The live CPU/RSS sample of this run's process tree, attached on the way out exactly as
    * `GET /runs` attaches it (`withUsage`) — never persisted.
@@ -1683,92 +1963,219 @@ var runIndexEntrySchema = z13.object({
    * belongs to. That is what lets a cross-project table show live usage without opening one
    * event stream per project (it could not — the run stream is project-scoped).
    */
-  usage: processUsageSchema.optional()
-});
-var referenceStatusesByProjectSchema = z13.record(
-  z13.string(),
-  z13.object({
-    prs: z13.record(z13.number(), referenceStatusSchema),
-    issues: z13.record(z13.number(), referenceStatusSchema)
+  usage: processUsageSchema.optional(),
+  /** The Workflow column's text (#817): for a `(planned)` or `(inbox)` chain, its first agent
+   *  step's name when it has one, otherwise `workflow`. Derived here because it is the one thing
+   *  a list row ever read off `steps[]`. */
+  workflowLabel: z14.string(),
+  /** Variant group membership (spec 010): the list collapses a group into one row. */
+  groupId: z14.string().optional(),
+  variant: z14.string().optional(),
+  pinned: z14.boolean().optional(),
+  runner: runRecordSchema.shape.runner,
+  model: z14.string().optional(),
+  notify: z14.boolean().optional(),
+  diffStat: diffStatSchema.optional(),
+  tokensUsed: z14.number(),
+  inputTokens: runRecordSchema.shape.inputTokens,
+  outputTokens: runRecordSchema.shape.outputTokens,
+  currentStepId: z14.string().optional(),
+  /** The backend of the step `currentStepId` names, when it recorded one — the conversation view
+   *  labels a delegated peer by the agent actually running it, which can differ from `runner`. */
+  currentStepBackend: runnerSchema.optional(),
+  error: z14.string().optional(),
+  /** Present while the run's isolated worktree exists — the breadcrumb says "Isolated worktree". */
+  worktreePath: z14.string().optional()
+});
+var runIndexEntrySchema = runSummarySchema.extend({
+  /** The registered project this run belongs to. Joins against `GET /projects`. */
+  projectId: z14.string()
+});
+var SUMMARY_OPTIONAL_KEYS = [
+  "titleSummary",
+  "titleOrigin",
+  "activity",
+  "hasPendingHumanAsk",
+  "finishedAt",
+  "seenAt",
+  "autoResumeAt",
+  "branch",
+  "startedAt",
+  "pullRequestUrl",
+  "referencedPullRequestUrl",
+  "prNumber",
+  "issueNumber",
+  "referencedIssueUrl",
+  "markerRefs",
+  "costUsd",
+  "peakRssBytes",
+  "peakProcCount",
+  "groupId",
+  "variant",
+  "pinned",
+  "runner",
+  "model",
+  "notify",
+  "diffStat",
+  "inputTokens",
+  "outputTokens",
+  "currentStepId",
+  "error",
+  "worktreePath"
+];
+function runWorkflowLabel(run) {
+  if (run.workflow === "(planned)" || run.workflow === "(inbox)") {
+    const agent = (run.steps ?? []).find((step) => step.kind === "agent");
+    if (agent?.name) return agent.name;
+  }
+  return run.workflow;
+}
+function toRunSummary(run) {
+  const summary = {
+    id: run.id,
+    title: run.title,
+    status: run.status,
+    createdAt: run.createdAt,
+    archived: run.archived,
+    workflow: run.workflow,
+    workflowLabel: runWorkflowLabel(run),
+    tokensUsed: run.tokensUsed
+  };
+  for (const key of SUMMARY_OPTIONAL_KEYS) {
+    if (run[key] !== void 0) summary[key] = run[key];
+  }
+  const currentStepBackend = (run.steps ?? []).find((step) => step.id === run.currentStepId)?.backend;
+  if (currentStepBackend !== void 0) summary.currentStepBackend = currentStepBackend;
+  if (run.delegation) {
+    const delegation = runDelegationSummarySchema.safeParse(run.delegation);
+    summary.delegation = delegation.success ? delegation.data : { role: "invalid" };
+  }
+  if (run.usage) summary.usage = run.usage;
+  return summary;
+}
+var referenceStatusesByProjectSchema = z14.record(
+  z14.string(),
+  z14.object({
+    prs: z14.record(z14.number(), referenceStatusSchema),
+    issues: z14.record(z14.number(), referenceStatusSchema)
   })
 );
-var runsIndexResponseSchema = z13.object({
-  /** Newest first, across every registered project. Archived runs are included — `GET /runs`
-   *  carries them for the project you are standing in, and a finder that dropped them elsewhere
-   *  would make a task vanish the moment you left its project. */
-  runs: z13.array(runIndexEntrySchema),
+var ARCHIVED_RUNS_PAGE_DEFAULT = 50;
+var ARCHIVED_RUNS_PAGE_MAX = 200;
+var runSummariesQuerySchema = z14.object({
+  archived: z14.enum(["recent", "all"]).optional()
+});
+var archivedRunsQuerySchema = z14.object({
+  /** `nextCursor` from the previous page. Opaque: a malformed one answers 400. */
+  before: z14.string().optional(),
+  limit: z14.coerce.number().int().min(1).max(ARCHIVED_RUNS_PAGE_MAX).optional(),
+  /** Only runs that match (`matchesRunQuery`): title, id, branch, workflow, PR or issue. */
+  q: z14.string().optional()
+});
+var archivedRunsResponseSchema = z14.object({
+  runs: z14.array(runSummarySchema),
+  /** The `before` of the next page, or null on the last one. */
+  nextCursor: z14.string().nullable(),
+  /** How many archived root runs match, across every page. */
+  total: z14.number().int().nonnegative()
+});
+var runsIndexResponseSchema = z14.object({
+  /** Newest first, across every registered project: each project's window (#864) — every
+   *  unarchived root run, plus its newest `perProjectLimit` archived root runs. Owned workers are
+   *  never included. Older archived runs are
+   *  reached through `GET /workspace/runs-search`. */
+  runs: z14.array(runIndexEntrySchema),
   /** Additive: absent statuses mean "nothing warm", never "nothing to show". */
   referenceStatuses: referenceStatusesByProjectSchema,
-  /** The per-project cap that produced this list. */
-  perProjectLimit: z13.number(),
-  /** Ids of the projects that had more runs than the cap allowed. */
-  truncated: z13.array(z13.string())
-});
-var createRunResponseSchema = z13.union([
+  /** How many archived root runs each project contributes at most. Unarchived roots are never cut. */
+  perProjectLimit: z14.number(),
+  /** Ids of the projects that had more archived root runs than `perProjectLimit`. */
+  truncated: z14.array(z14.string())
+});
+var RUNS_SEARCH_PER_PROJECT_MAX = 50;
+var runsSearchQuerySchema = z14.object({
+  /** Every whitespace-separated token must match (`matchesRunQuery`). At least two characters:
+   *  one matches nearly every run. */
+  q: z14.string().trim().min(2),
+  limit: z14.coerce.number().int().min(1).max(RUNS_SEARCH_PER_PROJECT_MAX).optional()
+});
+var runsSearchResponseSchema = z14.object({
+  /** Root runs, archived or not, newest first across every registered project. */
+  runs: z14.array(runIndexEntrySchema),
+  /** Ids of the projects that had more matches than `limit`. */
+  truncated: z14.array(z14.string())
+});
+var createRunResponseSchema = z14.union([
   runRecordSchema,
-  z13.object({ runs: z13.array(runRecordSchema) })
+  z14.object({ runs: z14.array(runRecordSchema) })
 ]);
-var cancelResponseSchema = z13.object({ cancelled: z13.boolean() });
-var cancelAutoResumeResponseSchema = z13.object({ cancelled: z13.literal(true) });
-var archiveFinishedResponseSchema = z13.object({ archived: z13.number() });
-var markAllReadResponseSchema = z13.object({ read: z13.number() });
-var deleteRunResponseSchema = z13.object({ deleted: z13.literal(true) });
-var finishResponseSchema = z13.object({ finished: z13.literal(true) });
-var continueResponseSchema = z13.object({ continued: z13.literal(true) });
-var createPrResponseSchema = z13.object({
-  url: z13.string(),
-  dryRun: z13.boolean()
-});
-var messageResponseSchema = z13.union([
-  z13.object({ delivered: z13.literal(true) }),
-  z13.object({ queued: z13.literal(true), message: queuedMessageSchema }),
-  z13.object({ deferred: z13.literal(true) })
+var cancelResponseSchema = z14.object({ cancelled: z14.boolean() });
+var cancelAutoResumeResponseSchema = z14.object({ cancelled: z14.literal(true) });
+var archiveFinishedScopeSchema = z14.enum(["unpinned", "pinned"]);
+var archiveFinishedRequestSchema = z14.object({ scope: archiveFinishedScopeSchema.optional() });
+var archiveFinishedResponseSchema = z14.object({
+  archived: z14.number(),
+  ids: z14.array(z14.string()),
+  pinnedIds: z14.array(z14.string())
+});
+var markAllReadResponseSchema = z14.object({ read: z14.number() });
+var deleteRunResponseSchema = z14.object({ deleted: z14.literal(true) });
+var finishResponseSchema = z14.object({ finished: z14.literal(true) });
+var continueResponseSchema = z14.object({ continued: z14.literal(true) });
+var createPrResponseSchema = z14.object({
+  url: z14.string(),
+  dryRun: z14.boolean()
+});
+var messageResponseSchema = z14.union([
+  z14.object({ delivered: z14.literal(true) }),
+  z14.object({ queued: z14.literal(true), message: queuedMessageSchema }),
+  z14.object({ deferred: z14.literal(true) })
 ]);
-var editQueuedMessageResponseSchema = z13.object({ message: queuedMessageSchema });
-var removeQueuedMessageResponseSchema = z13.object({ removed: z13.literal(true) });
-var openInCliResponseSchema = z13.object({
-  opened: z13.literal(true),
-  command: z13.string()
-});
-var removeWorktreeResponseSchema = z13.object({ removed: z13.literal(true) });
-var gitCommitResponseSchema = z13.object({
-  committed: z13.literal(true),
-  sha: z13.string()
-});
-var gitPushResponseSchema = z13.object({
-  pushed: z13.literal(true),
-  branch: z13.string(),
-  remote: z13.string(),
-  upstreamSet: z13.boolean()
-});
-var runCommitSchema = z13.object({
-  sha: z13.string(),
-  subject: z13.string(),
-  author: z13.string(),
+var editQueuedMessageResponseSchema = z14.object({ message: queuedMessageSchema });
+var removeQueuedMessageResponseSchema = z14.object({ removed: z14.literal(true) });
+var openInCliResponseSchema = z14.object({
+  opened: z14.literal(true),
+  command: z14.string()
+});
+var removeWorktreeResponseSchema = z14.object({ removed: z14.literal(true) });
+var gitCommitResponseSchema = z14.object({
+  committed: z14.literal(true),
+  sha: z14.string()
+});
+var gitPushResponseSchema = z14.object({
+  pushed: z14.literal(true),
+  branch: z14.string(),
+  remote: z14.string(),
+  upstreamSet: z14.boolean()
+});
+var runCommitSchema = z14.object({
+  sha: z14.string(),
+  subject: z14.string(),
+  author: z14.string(),
   /** Relative time ("3 hours ago") — git's `%cr`. */
-  when: z13.string()
+  when: z14.string()
 });
-var runCommitsResponseSchema = z13.object({ commits: z13.array(runCommitSchema) });
-var groupVariantSchema = z13.object({
-  id: z13.string(),
+var runCommitsResponseSchema = z14.object({ commits: z14.array(runCommitSchema) });
+var groupVariantSchema = z14.object({
+  id: z14.string(),
   /** 'A' | 'B' | 'C' in practice; `'?'` for a record that lost its letter. */
-  variant: z13.string(),
-  title: z13.string(),
+  variant: z14.string(),
+  title: z14.string(),
   status: runStatusSchema,
-  archived: z13.boolean(),
-  tokensUsed: z13.number(),
+  archived: z14.boolean(),
+  tokensUsed: z14.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
-  costUsd: z13.number().optional(),
-  diffStat: z13.string(),
+  costUsd: z14.number().optional(),
+  diffStat: z14.string(),
   /** First lines of the handoff journal's "## Progress log" section, as markdown. */
-  handoffExcerpt: z13.string()
+  handoffExcerpt: z14.string()
 });
-var groupResponseSchema = z13.object({
-  groupId: z13.string(),
-  runs: z13.array(groupVariantSchema)
+var groupResponseSchema = z14.object({
+  groupId: z14.string(),
+  runs: z14.array(groupVariantSchema)
 });
-var pickVariantResponseSchema = z13.object({
+var pickVariantResponseSchema = z14.object({
   winner: runRecordSchema.optional()
 });
 var FILE_ATTACHMENT_MEDIA_TYPES = [
@@ -1791,80 +2198,80 @@ function isImageAttachmentName(name) {
   const ext = name.split(".").pop()?.toLowerCase();
   return ext !== void 0 && IMAGE_ATTACHMENT_EXTENSIONS.has(ext);
 }
-var attachmentFileParamSchema = z13.object({
-  id: z13.string().min(1),
-  file: z13.string().regex(/^[A-Za-z0-9_-][A-Za-z0-9._-]*$/).refine((name) => !name.includes(".."))
+var attachmentFileParamSchema = z14.object({
+  id: z14.string().min(1),
+  file: z14.string().regex(/^[A-Za-z0-9_-][A-Za-z0-9._-]*$/).refine((name) => !name.includes(".."))
 });
-var attachmentInputSchema = z13.object({
-  mediaType: z13.string().refine(isAttachmentMediaType, {
+var attachmentInputSchema = z14.object({
+  mediaType: z14.string().refine(isAttachmentMediaType, {
     message: "unsupported attachment type \u2014 images, plain text, markdown and PDF only"
   }),
-  data: z13.string().min(1).max(7e6)
+  data: z14.string().min(1).max(7e6)
 });
 var imageInputSchema = attachmentInputSchema;
 var CLIENT_REQUEST_VARIANTS_ERROR = "clientRequestId names one run; it cannot be combined with variants > 1";
-var createRunInputBaseSchema = z13.object({
-  workflow: z13.string().min(1).optional(),
+var createRunInputBaseSchema = z14.object({
+  workflow: z14.string().min(1).optional(),
   /** An inline chain (spec 008 — an approved plan runs as an ad-hoc workflow, never written to
    *  a file). The catalog's own step shape, not a copy of it. */
-  steps: z13.array(workflowStepDefSchema).min(1).max(8).optional(),
-  task: z13.string().min(1).max(1e5, "must be at most 100000 characters"),
-  model: z13.string().optional(),
+  steps: z14.array(workflowStepDefSchema).min(1).max(8).optional(),
+  task: z14.string().min(1).max(1e5, "must be at most 100000 characters"),
+  model: z14.string().optional(),
   /** Reasoning-effort pin (#45). Omit for the harness default; empty/`auto` stay implicit. */
-  effort: z13.string().max(32).optional(),
+  effort: z14.string().max(32).optional(),
   runner: runnerSchema.optional(),
   /** Agent account for this task (spec 2026-07-29-agent-profiles). Omit to follow the
    *  project's own selection; an id that no longer exists is a 400, not a silent default. */
-  agentProfile: z13.string().max(64).optional(),
+  agentProfile: z14.string().max(64).optional(),
   /** 1–3. Above 1 the response is `{ runs }` rather than a single record. */
-  variants: z13.number().int().min(1).max(3).optional(),
+  variants: z14.number().int().min(1).max(3).optional(),
   /** false → run in the repo working tree instead of an isolated worktree (read-only skills).
    *  Omit for the default. Ignored server-side when variants > 1. */
-  worktree: z13.boolean().optional(),
+  worktree: z14.boolean().optional(),
   /** true → autonomous run: never parks at "waiting"; auto-continues until done. */
-  autonomous: z13.boolean().optional(),
+  autonomous: z14.boolean().optional(),
   /** false → keep the handoff journal but do not expose or request a follow-up todos file.
    *  Omit for the default (enabled); a server with the capability off pins it to false. */
-  generateFollowups: z13.boolean().optional(),
+  generateFollowups: z14.boolean().optional(),
   /** Per-run system-prompt override (R2 2.3) — programmatic callers only. Wins over the
    *  config.json default; whitespace-only degrades to absent. */
-  systemPrompt: z13.string().trim().max(2e4, "must be at most 20000 characters").optional().transform((s) => s ? s : void 0),
+  systemPrompt: z14.string().trim().max(2e4, "must be at most 20000 characters").optional().transform((s) => s ? s : void 0),
   /** Attachments pasted into the new-task form — screenshots, and since #950 PDF/TXT/MD files
    *  too; delivered with the first agent step. The key keeps its name: the wire contract widened
    *  in place rather than growing a second list. */
-  images: z13.array(attachmentInputSchema).max(4).optional(),
+  images: z14.array(attachmentInputSchema).max(4).optional(),
   /** The inbox entry this task came from (#374). Best-effort bookkeeping: an unknown or
    *  already-started id never fails the run. For ×2/×3 the FIRST variant is recorded. */
-  todoId: z13.string().min(1).max(200, "must be at most 200 characters").optional()
+  todoId: z14.string().min(1).max(200, "must be at most 200 characters").optional()
 });
 var createRunInputSchema = createRunInputBaseSchema.extend({
   /** Idempotent start (#504): a retry with the same id and payload answers `200` with the run
    *  the first request created; a different payload answers `409`. Scoped to the project. Not
    *  on the base schema, so an automation's task definition cannot carry one. */
-  clientRequestId: z13.string().uuid().optional(),
+  clientRequestId: z14.string().uuid().optional(),
   /** Task webhook opt-in (#589). Absent = off. `true` on a project with no webhook is a 400.
    *  Not on the base schema, and not part of the idempotent-start hash: it can change later. */
-  notify: z13.boolean().optional()
+  notify: z14.boolean().optional()
 }).refine(
   (b) => Boolean(b.workflow) !== Boolean(b.steps),
   { message: 'provide either "workflow" or "steps", not both' }
 ).refine((b) => !(b.clientRequestId && (b.variants ?? 1) > 1), {
   message: CLIENT_REQUEST_VARIANTS_ERROR
 });
-var messageInputSchema = z13.object({
-  text: z13.string().max(1e5).default(""),
-  images: z13.array(attachmentInputSchema).max(4).default([])
+var messageInputSchema = z14.object({
+  text: z14.string().max(1e5).default(""),
+  images: z14.array(attachmentInputSchema).max(4).default([])
 }).refine((m) => m.text.trim().length > 0 || m.images.length > 0, {
   message: "message needs text or at least one attachment"
 });
-var patchRunInputSchema = z13.object({
-  title: z13.string().trim().min(1).max(300).optional(),
-  task: z13.string().trim().min(1).max(1e5).optional()
+var patchRunInputSchema = z14.object({
+  title: z14.string().trim().min(1).max(300).optional(),
+  task: z14.string().trim().min(1).max(1e5).optional()
 });
-var pinRunInputSchema = z13.object({ pinned: z13.boolean().optional() });
-var notifyRunInputSchema = z13.object({
-  notify: z13.boolean(),
-  message: z13.string().trim().max(1e5).optional().transform((text) => text ? text : void 0)
+var pinRunInputSchema = z14.object({ pinned: z14.boolean().optional() });
+var notifyRunInputSchema = z14.object({
+  notify: z14.boolean(),
+  message: z14.string().trim().max(1e5).optional().transform((text) => text ? text : void 0)
 });
 
 // ../contract/src/attention.ts
@@ -1932,162 +2339,162 @@ function deriveAttention(run, hasPendingHumanAsk = false) {
 }
 
 // ../contract/src/repo.ts
-import { z as z14 } from "zod";
-var statusEntrySchema = z14.object({
-  status: z14.string(),
-  path: z14.string()
-});
-var logEntrySourceSchema = z14.object({
-  runId: z14.string(),
-  title: z14.string(),
-  prNumber: z14.number().nullable()
-});
-var logEntrySchema = z14.object({
-  hash: z14.string(),
-  subject: z14.string(),
-  author: z14.string(),
-  when: z14.string(),
-  at: z14.string(),
+import { z as z15 } from "zod";
+var statusEntrySchema = z15.object({
+  status: z15.string(),
+  path: z15.string()
+});
+var logEntrySourceSchema = z15.object({
+  runId: z15.string(),
+  title: z15.string(),
+  prNumber: z15.number().nullable()
+});
+var logEntrySchema = z15.object({
+  hash: z15.string(),
+  subject: z15.string(),
+  author: z15.string(),
+  when: z15.string(),
+  at: z15.string(),
   source: logEntrySourceSchema.optional()
 });
-var repoTrackingSchema = z14.object({
-  ref: z14.string(),
-  ahead: z14.number(),
-  behind: z14.number(),
-  fetchedAt: z14.string().nullable()
-});
-var repoResponseSchema = z14.union([
-  z14.object({
-    info: z14.null(),
-    status: z14.array(z14.never()),
-    log: z14.array(z14.never()),
-    branches: z14.array(z14.never()),
-    baseBranch: z14.null(),
-    tracking: z14.null()
+var repoTrackingSchema = z15.object({
+  ref: z15.string(),
+  ahead: z15.number(),
+  behind: z15.number(),
+  fetchedAt: z15.string().nullable()
+});
+var repoResponseSchema = z15.union([
+  z15.object({
+    info: z15.null(),
+    status: z15.array(z15.never()),
+    log: z15.array(z15.never()),
+    branches: z15.array(z15.never()),
+    baseBranch: z15.null(),
+    tracking: z15.null()
   }),
-  z14.object({
+  z15.object({
     info: repoInfoSchema,
-    status: z14.array(statusEntrySchema),
-    log: z14.array(logEntrySchema),
-    branches: z14.array(z14.string()),
-    baseBranch: z14.string().nullable(),
+    status: z15.array(statusEntrySchema),
+    log: z15.array(logEntrySchema),
+    branches: z15.array(z15.string()),
+    baseBranch: z15.string().nullable(),
     tracking: repoTrackingSchema.nullable()
   })
 ]);
-var repoBranchResponseSchema = z14.object({
-  branch: z14.string(),
-  created: z14.boolean()
+var repoBranchResponseSchema = z15.object({
+  branch: z15.string(),
+  created: z15.boolean()
 });
-var branchClassSchema = z14.enum(["active", "not-landed", "orphan", "merged", "empty", "other"]);
-var branchPrStateSchema = z14.enum(["open", "draft", "merged", "closed"]);
-var repoBranchEntrySchema = z14.object({
-  name: z14.string(),
+var branchClassSchema = z15.enum(["active", "not-landed", "orphan", "merged", "empty", "other"]);
+var branchPrStateSchema = z15.enum(["open", "draft", "merged", "closed"]);
+var repoBranchEntrySchema = z15.object({
+  name: z15.string(),
   class: branchClassSchema,
-  runId: z14.string().nullable(),
-  title: z14.string().nullable(),
+  runId: z15.string().nullable(),
+  title: z15.string().nullable(),
   runStatus: runStatusSchema.nullable(),
   /** Commits on the branch that are not reachable from the base. */
-  ahead: z14.number(),
-  lastCommit: z14.object({ sha: z14.string(), subject: z14.string(), at: z14.string() }),
+  ahead: z15.number(),
+  lastCommit: z15.object({ sha: z15.string(), subject: z15.string(), at: z15.string() }),
   /** `--shortstat <base>...<branch>`, for `not-landed` and `orphan` rows only. */
-  diffStat: z14.object({ additions: z14.number(), deletions: z14.number() }).nullable(),
-  pr: z14.object({ number: z14.number(), url: z14.string(), state: branchPrStateSchema }).nullable()
-});
-var repoBranchesResponseSchema = z14.object({
-  base: z14.string(),
-  prStateKnown: z14.boolean(),
-  branches: z14.array(repoBranchEntrySchema),
-  counts: z14.object({ notLanded: z14.number(), cleanup: z14.number() })
-});
-var deleteBranchesInputSchema = z14.object({
-  names: z14.array(z14.string().trim().min(1).max(250)).min(1).max(500),
-  confirm: z14.string().optional()
-});
-var branchRefusalSchema = z14.object({ name: z14.string(), reason: z14.string() });
-var deleteBranchesResponseSchema = z14.object({
-  deleted: z14.array(z14.string()),
-  refused: z14.array(branchRefusalSchema),
-  dropped: z14.array(z14.object({ sha: z14.string(), subject: z14.string() })).optional()
-});
-var deleteBranchesErrorSchema = z14.object({
-  error: z14.string(),
-  refused: z14.array(branchRefusalSchema)
-});
-var repoPullBranchesResponseSchema = z14.object({ branches: z14.array(z14.string()) });
-var repoPullInputSchema = z14.object({
-  branch: z14.string().trim().min(1).max(200).optional(),
-  confirm: z14.boolean().optional()
-});
-var repoPullResponseSchema = z14.object({
-  branch: z14.string(),
-  pulled: z14.literal(true),
-  summary: z14.string()
-});
-var repoPullConfirmationSchema = z14.object({
-  error: z14.string(),
-  branch: z14.string(),
-  risks: z14.array(z14.enum(["active_runs", "dirty_tree"]))
-});
-var repoPullErrorSchema = z14.union([
+  diffStat: z15.object({ additions: z15.number(), deletions: z15.number() }).nullable(),
+  pr: z15.object({ number: z15.number(), url: z15.string(), state: branchPrStateSchema }).nullable()
+});
+var repoBranchesResponseSchema = z15.object({
+  base: z15.string(),
+  prStateKnown: z15.boolean(),
+  branches: z15.array(repoBranchEntrySchema),
+  counts: z15.object({ notLanded: z15.number(), cleanup: z15.number() })
+});
+var deleteBranchesInputSchema = z15.object({
+  names: z15.array(z15.string().trim().min(1).max(250)).min(1).max(500),
+  confirm: z15.string().optional()
+});
+var branchRefusalSchema = z15.object({ name: z15.string(), reason: z15.string() });
+var deleteBranchesResponseSchema = z15.object({
+  deleted: z15.array(z15.string()),
+  refused: z15.array(branchRefusalSchema),
+  dropped: z15.array(z15.object({ sha: z15.string(), subject: z15.string() })).optional()
+});
+var deleteBranchesErrorSchema = z15.object({
+  error: z15.string(),
+  refused: z15.array(branchRefusalSchema)
+});
+var repoPullBranchesResponseSchema = z15.object({ branches: z15.array(z15.string()) });
+var repoPullInputSchema = z15.object({
+  branch: z15.string().trim().min(1).max(200).optional(),
+  confirm: z15.boolean().optional()
+});
+var repoPullResponseSchema = z15.object({
+  branch: z15.string(),
+  pulled: z15.literal(true),
+  summary: z15.string()
+});
+var repoPullConfirmationSchema = z15.object({
+  error: z15.string(),
+  branch: z15.string(),
+  risks: z15.array(z15.enum(["active_runs", "dirty_tree"]))
+});
+var repoPullErrorSchema = z15.union([
   repoPullConfirmationSchema,
-  z14.object({ error: z14.string() })
+  z15.object({ error: z15.string() })
 ]);
-var diffStatSchema2 = z14.object({
-  adds: z14.number(),
-  dels: z14.number(),
-  files: z14.number()
+var diffStatSchema2 = z15.object({
+  adds: z15.number(),
+  dels: z15.number(),
+  files: z15.number()
 });
-var changedFileSchema = z14.object({
-  path: z14.string(),
+var changedFileSchema = z15.object({
+  path: z15.string(),
   /** Rename/copy source — present only when `status` is renamed/copied. */
-  oldPath: z14.string().optional(),
-  status: z14.enum(["added", "modified", "deleted", "renamed", "copied"]),
-  adds: z14.number(),
-  dels: z14.number(),
+  oldPath: z15.string().optional(),
+  status: z15.enum(["added", "modified", "deleted", "renamed", "copied"]),
+  adds: z15.number(),
+  dels: z15.number(),
   /** Binary per numstat — there is no text patch to render. */
-  binary: z14.boolean(),
+  binary: z15.boolean(),
   /** True when the path is one the raw-bytes route serves as an `<img>` (#365) — present only
    *  when true, so old clients that never read it stay correct. */
-  image: z14.boolean().optional(),
+  image: z15.boolean().optional(),
   /** This file's unified-diff section; possibly `… (patch truncated)`, possibly empty. */
-  patch: z14.string()
+  patch: z15.string()
 });
-var changesPayloadSchema = z14.object({
-  files: z14.array(changedFileSchema),
+var changesPayloadSchema = z15.object({
+  files: z15.array(changedFileSchema),
   stat: diffStatSchema2,
   /** Additive context for review tasks whose worktree HEAD no longer matches their own branch. */
-  repointedHead: z14.object({ headBranch: z14.string(), taskBranch: z14.string() }).optional()
+  repointedHead: z15.object({ headBranch: z15.string(), taskBranch: z15.string() }).optional()
 });
-var repoCommitPayloadSchema = z14.object({
-  sha: z14.string(),
-  subject: z14.string(),
-  author: z14.string(),
+var repoCommitPayloadSchema = z15.object({
+  sha: z15.string(),
+  subject: z15.string(),
+  author: z15.string(),
   /** Relative time ("3 hours ago") — same `%cr` format as the /api/v1/repo log. */
-  when: z14.string(),
-  files: z14.array(changedFileSchema),
+  when: z15.string(),
+  files: z15.array(changedFileSchema),
   stat: diffStatSchema2
 });
-var worktreeDirEntrySchema = z14.object({
-  name: z14.string(),
-  type: z14.enum(["dir", "file"]),
-  size: z14.number().optional()
-});
-var worktreeEntrySchema = z14.discriminatedUnion("type", [
-  z14.object({
-    type: z14.literal("dir"),
-    path: z14.string(),
-    entries: z14.array(worktreeDirEntrySchema)
+var worktreeDirEntrySchema = z15.object({
+  name: z15.string(),
+  type: z15.enum(["dir", "file"]),
+  size: z15.number().optional()
+});
+var worktreeEntrySchema = z15.discriminatedUnion("type", [
+  z15.object({
+    type: z15.literal("dir"),
+    path: z15.string(),
+    entries: z15.array(worktreeDirEntrySchema)
   }),
-  z14.object({
-    type: z14.literal("file"),
-    path: z14.string(),
-    size: z14.number(),
-    binary: z14.boolean(),
-    tooLarge: z14.boolean(),
-    content: z14.string().optional()
+  z15.object({
+    type: z15.literal("file"),
+    path: z15.string(),
+    size: z15.number(),
+    binary: z15.boolean(),
+    tooLarge: z15.boolean(),
+    content: z15.string().optional()
   })
 ]);
-var worktreeRunStatusSchema = z14.enum([
+var worktreeRunStatusSchema = z15.enum([
   "queued",
   "running",
   "waiting",
@@ -2096,46 +2503,46 @@ var worktreeRunStatusSchema = z14.enum([
   "failed",
   "cancelled"
 ]);
-var worktreeInfoSchema = z14.object({
-  runId: z14.string(),
-  title: z14.string(),
+var worktreeInfoSchema = z15.object({
+  runId: z15.string(),
+  title: z15.string(),
   status: worktreeRunStatusSchema,
-  branch: z14.string().nullable(),
-  sizeBytes: z14.number().nullable(),
-  finishedAt: z14.string().nullable(),
-  reclaimable: z14.boolean(),
-  pastKeep: z14.boolean()
+  branch: z15.string().nullable(),
+  sizeBytes: z15.number().nullable(),
+  finishedAt: z15.string().nullable(),
+  reclaimable: z15.boolean(),
+  pastKeep: z15.boolean()
 });
-var worktreesResponseSchema = z14.object({
-  worktrees: z14.array(worktreeInfoSchema),
-  totalBytes: z14.number().nullable(),
-  keep: z14.number()
+var worktreesResponseSchema = z15.object({
+  worktrees: z15.array(worktreeInfoSchema),
+  totalBytes: z15.number().nullable(),
+  keep: z15.number()
 });
-var reclaimWorktreeResponseSchema = z14.object({
-  runId: z14.string(),
-  worktreeReclaimedAt: z14.string()
+var reclaimWorktreeResponseSchema = z15.object({
+  runId: z15.string(),
+  worktreeReclaimedAt: z15.string()
 });
-var reclaimWorktreesResponseSchema = z14.object({
-  reclaimed: z14.array(z14.string())
+var reclaimWorktreesResponseSchema = z15.object({
+  reclaimed: z15.array(z15.string())
 });
 
 // ../contract/src/projects.ts
-import { z as z15 } from "zod";
-var projectListEntrySchema = z15.object({
-  id: z15.string(),
-  name: z15.string(),
+import { z as z16 } from "zod";
+var projectListEntrySchema = z16.object({
+  id: z16.string(),
+  name: z16.string(),
   /** Absolute, realpath-normalized repo root. */
-  root: z15.string(),
-  addedAt: z15.string(),
-  lastOpenedAt: z15.string(),
-  source: z15.enum(["local", "checkout"]),
+  root: z16.string(),
+  addedAt: z16.string(),
+  lastOpenedAt: z16.string(),
+  source: z16.enum(["local", "checkout"]),
   /** `not-git` is fully usable (degraded single-queue mode); only `missing` blocks. */
-  status: z15.enum(["ok", "missing", "not-git"]),
+  status: z16.enum(["ok", "missing", "not-git"]),
   /** Current branch when cheaply available (omitted e.g. on an unborn HEAD). */
-  branch: z15.string().optional(),
+  branch: z16.string().optional(),
   /** Which forge this project's remote belongs to (#698) — classified server-side from the
    *  remote URL alone. Gates the project group's GitHub nav item; omitted = no forge remote. */
-  forge: z15.literal("github").optional(),
+  forge: z16.literal("github").optional(),
   /**
    * The remote's web root, `https://github.com/owner/repo`. Rebuilt server-side from the parsed
    * remote rather than passed through, so a remote carrying credentials cannot leak into the
@@ -2145,10 +2552,10 @@ var projectListEntrySchema = z15.object({
    * the global Tasks page has one row per project, so it cannot use any single repo's base the
    * way a project-scoped view can. With this, every reference it shows is a link.
    */
-  repoUrl: z15.string().optional(),
+  repoUrl: z16.string().optional(),
   /** Per-project cap on concurrently running tasks (spec 2026-07-22). Omitted = inherit the
    *  workspace `resources.maxParallel`; a number pins this project. */
-  maxParallel: z15.number().optional(),
+  maxParallel: z16.number().optional(),
   /**
    * Free-form labels grouping CONNECTED repositories — a `storefront` tag on the API, the web
    * app and the design system says those three are one piece of work spread over three repos.
@@ -2160,44 +2567,44 @@ var projectListEntrySchema = z15.object({
    * server-side (trimmed, deduped case-insensitively, sorted), so a consumer may compare them
    * directly.
    */
-  tags: z15.array(z15.string()).optional(),
+  tags: z16.array(z16.string()).optional(),
   /** The task webhook (#589). The token is write-only: the wire says only whether one is set. */
-  webhook: z15.object({ url: z15.string(), tokenSet: z15.boolean() }).optional()
+  webhook: z16.object({ url: z16.string(), tokenSet: z16.boolean() }).optional()
 });
-var projectsResponseSchema = z15.object({
-  projects: z15.array(projectListEntrySchema),
-  bootProject: z15.string(),
-  projectsDir: z15.string()
+var projectsResponseSchema = z16.object({
+  projects: z16.array(projectListEntrySchema),
+  bootProject: z16.string(),
+  projectsDir: z16.string()
 });
-var registerProjectResponseSchema = z15.object({
+var registerProjectResponseSchema = z16.object({
   project: projectListEntrySchema,
-  error: z15.string().optional()
+  error: z16.string().optional()
 });
-var removeProjectResponseSchema = z15.object({
-  removed: z15.literal(true),
-  id: z15.string()
+var removeProjectResponseSchema = z16.object({
+  removed: z16.literal(true),
+  id: z16.string()
 });
-var updateProjectResponseSchema = z15.object({
+var updateProjectResponseSchema = z16.object({
   project: projectListEntrySchema
 });
 var PROJECT_TAG_MAX_LENGTH = 32;
 var PROJECT_TAGS_MAX = 20;
 var PROJECT_WEBHOOK_URL_MAX_LENGTH = 2048;
 var PROJECT_WEBHOOK_TOKEN_MAX_LENGTH = 1024;
-var projectWebhookUrlSchema = z15.string().trim().max(PROJECT_WEBHOOK_URL_MAX_LENGTH).pipe(z15.url({ protocol: /^https?$/, error: "webhook url must be an http(s) URL" })).refine((value) => !/^https?:\/\/[^/?#]*@/i.test(value), "webhook url must not contain credentials; put the secret in the token");
-var projectWebhookInputSchema = z15.object({
+var projectWebhookUrlSchema = z16.string().trim().max(PROJECT_WEBHOOK_URL_MAX_LENGTH).pipe(z16.url({ protocol: /^https?$/, error: "webhook url must be an http(s) URL" })).refine((value) => !/^https?:\/\/[^/?#]*@/i.test(value), "webhook url must not contain credentials; put the secret in the token");
+var projectWebhookInputSchema = z16.object({
   url: projectWebhookUrlSchema,
-  token: z15.string().trim().max(PROJECT_WEBHOOK_TOKEN_MAX_LENGTH).optional()
+  token: z16.string().trim().max(PROJECT_WEBHOOK_TOKEN_MAX_LENGTH).optional()
 });
-var testProjectWebhookResponseSchema = z15.object({
-  ok: z15.boolean(),
-  status: z15.number().optional(),
-  error: z15.string().optional(),
-  dryRun: z15.boolean().optional()
+var testProjectWebhookResponseSchema = z16.object({
+  ok: z16.boolean(),
+  status: z16.number().optional(),
+  error: z16.string().optional(),
+  dryRun: z16.boolean().optional()
 });
-var updateProjectInputSchema = z15.object({
-  maxParallel: z15.number().int().min(1).max(16).nullable().optional(),
-  tags: z15.array(z15.string().trim().min(1).max(PROJECT_TAG_MAX_LENGTH)).max(PROJECT_TAGS_MAX).nullable().optional(),
+var updateProjectInputSchema = z16.object({
+  maxParallel: z16.number().int().min(1).max(16).nullable().optional(),
+  tags: z16.array(z16.string().trim().min(1).max(PROJECT_TAG_MAX_LENGTH)).max(PROJECT_TAGS_MAX).nullable().optional(),
   /**
    * The task webhook (#589). `null` removes it. An omitted `token` keeps the stored one, so the
    * settings form can change the URL without asking for a secret it never shows again; `''`
@@ -2208,170 +2615,170 @@ var updateProjectInputSchema = z15.object({
   (body) => body.maxParallel !== void 0 || body.tags !== void 0 || body.webhook !== void 0,
   "specify maxParallel, tags or webhook"
 );
-var checkoutProjectInputSchema = z15.object({
-  url: z15.string().trim().min(1).max(512),
-  name: z15.string().trim().max(128).optional(),
-  checkoutId: z15.string().trim().max(128).optional()
+var checkoutProjectInputSchema = z16.object({
+  url: z16.string().trim().min(1).max(512),
+  name: z16.string().trim().max(128).optional(),
+  checkoutId: z16.string().trim().max(128).optional()
 });
-var fsBrowseDirSchema = z15.object({
-  name: z15.string(),
-  path: z15.string(),
+var fsBrowseDirSchema = z16.object({
+  name: z16.string(),
+  path: z16.string(),
   /** Has a `.git` entry — drives the "git" badge. A non-repo folder is still selectable. */
-  isRepo: z15.boolean()
+  isRepo: z16.boolean()
 });
-var fsBrowseResponseSchema = z15.object({
+var fsBrowseResponseSchema = z16.object({
   /** The realpath'd directory actually listed — never the spelling asked for, so the breadcrumb
    *  shows where the picker really is. */
-  path: z15.string(),
+  path: z16.string(),
   /** `null` AT the browse root: there is no "up" out of it, and the dialog must render no parent
    *  row rather than one that 400s. */
-  parent: z15.string().nullable(),
-  dirs: z15.array(fsBrowseDirSchema),
+  parent: z16.string().nullable(),
+  dirs: z16.array(fsBrowseDirSchema),
   /** True when the listing was capped server-side — surfaced honestly instead of showing a
    *  silently short list. */
-  truncated: z15.boolean()
+  truncated: z16.boolean()
 });
-var launchKeyResponseSchema = z15.object({
-  key: z15.string()
+var launchKeyResponseSchema = z16.object({
+  key: z16.string()
 });
 
 // ../contract/src/skills.ts
-import { z as z16 } from "zod";
-var skillSchema = z16.object({
-  name: z16.string(),
-  description: z16.string().optional(),
+import { z as z17 } from "zod";
+var skillSchema = z17.object({
+  name: z17.string(),
+  description: z17.string().optional(),
   /** Advisory hint for untouched composer run-mode choices. */
-  interactive: z16.literal(true).optional(),
-  body: z16.string(),
-  path: z16.string(),
-  source: z16.enum(["ai", "cezar", "agents", "global", "team"]),
+  interactive: z17.literal(true).optional(),
+  body: z17.string(),
+  path: z17.string(),
+  source: z17.enum(["ai", "cezar", "agents", "global", "team"]),
   /** Team skills only: where the definition lives in its skills repo. */
-  team: z16.object({
-    repo: z16.string(),
-    ref: z16.string(),
-    path: z16.string(),
+  team: z17.object({
+    repo: z17.string(),
+    ref: z17.string(),
+    path: z17.string(),
     /** True for the `SKILL.md` convention — a whole directory (references/…). */
-    dir: z16.boolean(),
+    dir: z17.boolean(),
     /**
      * The exact commit `ref` resolved to when the skill was read (#428).
      *
      * The hand-written DTO omitted this field entirely — it was NARROWER than the route,
      * which has served it since #428.
      */
-    commit: z16.string().optional()
+    commit: z17.string().optional()
   }).optional()
 });
-var importableSkillSchema = z16.object({
-  name: z16.string(),
-  description: z16.string().optional()
+var importableSkillSchema = z17.object({
+  name: z17.string(),
+  description: z17.string().optional()
 });
-var todoItemSchema = z16.object({
-  id: z16.string(),
-  ts: z16.string().optional(),
-  taskId: z16.string().optional(),
-  summary: z16.string().min(1),
-  action: z16.string().optional(),
-  prUrl: z16.string().optional(),
-  suggestedSkill: z16.string().optional(),
-  suggestedArgs: z16.string().optional(),
-  suggestedPrompt: z16.string().optional(),
+var todoItemSchema = z17.object({
+  id: z17.string(),
+  ts: z17.string().optional(),
+  taskId: z17.string().optional(),
+  summary: z17.string().min(1),
+  action: z17.string().optional(),
+  prUrl: z17.string().optional(),
+  suggestedSkill: z17.string().optional(),
+  suggestedArgs: z17.string().optional(),
+  suggestedPrompt: z17.string().optional(),
   /** Explicit intent; missing infers from suggestedSkill/suggestedPrompt for old files. */
-  runnable: z16.boolean().optional(),
+  runnable: z17.boolean().optional(),
   /** Set once a task was started from this entry — it then leaves the inbox and stays as
    *  the audit trail. A later launch never overwrites the first. */
-  startedTaskId: z16.string().optional()
+  startedTaskId: z17.string().optional()
 });
-var removeTodoResponseSchema = z16.object({
-  removed: z16.literal(true)
+var removeTodoResponseSchema = z17.object({
+  removed: z17.literal(true)
 });
-var startTodoResponseSchema = z16.object({
+var startTodoResponseSchema = z17.object({
   run: runRecordSchema
 });
 
 // ../contract/src/agent-config.ts
-import { z as z17 } from "zod";
-var agentConfigFormatSchema = z17.enum(["json", "jsonc", "toml", "markdown"]);
-var agentConfigScopeSchema = z17.enum(["user", "project", "local"]);
-var agentConfigKindSchema = z17.enum(["settings", "memory", "mcp"]);
-var agentConfigTrackedSchema = z17.enum(["tracked", "gitignored", "outside-repo"]);
-var agentConfigFileSchema = z17.object({
+import { z as z18 } from "zod";
+var agentConfigFormatSchema = z18.enum(["json", "jsonc", "toml", "yaml", "markdown"]);
+var agentConfigScopeSchema = z18.enum(["user", "project", "local"]);
+var agentConfigKindSchema = z18.enum(["settings", "memory", "mcp"]);
+var agentConfigTrackedSchema = z18.enum(["tracked", "gitignored", "outside-repo"]);
+var agentConfigFileSchema = z18.object({
   /** Stable, opaque, URL-safe — the ONLY thing a client may name (traversal-proof). */
-  id: z17.string(),
+  id: z18.string(),
   /** Every runner that reads this file: `<repo>/AGENTS.md` is one file, two readers. */
-  runners: z17.array(runnerSchema),
+  runners: z18.array(runnerSchema),
   kind: agentConfigKindSchema,
   scope: agentConfigScopeSchema,
-  label: z17.string(),
-  path: z17.string(),
+  label: z18.string(),
+  path: z18.string(),
   format: agentConfigFormatSchema,
   tracked: agentConfigTrackedSchema,
-  seeded: z17.boolean(),
-  holdsMcp: z17.boolean(),
+  seeded: z18.boolean(),
+  holdsMcp: z18.boolean(),
   /** VERBATIM from the vendor docs. Never computed, never generic. */
-  precedence: z17.string(),
+  precedence: z18.string(),
   /** Documented mid-run reload behaviour, or absent when the vendor is silent. */
-  hotReload: z17.string().optional(),
-  docsUrl: z17.string(),
-  exists: z17.boolean(),
-  size: z17.number(),
+  hotReload: z18.string().optional(),
+  docsUrl: z18.string(),
+  exists: z18.boolean(),
+  size: z18.number(),
   /** sha256 of the bytes, or null when absent. */
-  version: z17.string().nullable(),
+  version: z18.string().nullable(),
   /** False in hosted mode (whole feature) — the client renders read-only up front. */
-  writable: z17.boolean(),
-  readOnlyReason: z17.string().optional()
+  writable: z18.boolean(),
+  readOnlyReason: z18.string().optional()
 });
-var userMcpListingSchema = z17.object({
-  path: z17.string(),
-  servers: z17.array(z17.string()),
-  readable: z17.boolean()
+var userMcpListingSchema = z18.object({
+  path: z18.string(),
+  servers: z18.array(z18.string()),
+  readable: z18.boolean()
 });
-var agentConfigListingSchema = z17.object({
-  editable: z17.boolean(),
-  files: z17.array(agentConfigFileSchema),
+var agentConfigListingSchema = z18.object({
+  editable: z18.boolean(),
+  files: z18.array(agentConfigFileSchema),
   /** null in hosted mode (host-state disclosure guard). */
   userMcp: userMcpListingSchema.nullable()
 });
-var agentConfigFileContentSchema = z17.object({
-  id: z17.string(),
-  path: z17.string(),
-  exists: z17.boolean(),
-  content: z17.string(),
+var agentConfigFileContentSchema = z18.object({
+  id: z18.string(),
+  path: z18.string(),
+  exists: z18.boolean(),
+  content: z18.string(),
   /** sha256 of the bytes, or null when the file does not exist yet. */
-  version: z17.string().nullable()
+  version: z18.string().nullable()
 });
-var setAgentConfigInputSchema = z17.object({
-  content: z17.string().max(2e6),
-  version: z17.string().nullable()
+var setAgentConfigInputSchema = z18.object({
+  content: z18.string().max(2e6),
+  version: z18.string().nullable()
 });
 
 // ../contract/src/agent-profiles.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var DEFAULT_AGENT_ACCOUNT_ID = "default";
-var agentAccountFileSchema = z18.object({
-  id: z18.string(),
+var agentAccountFileSchema = z19.object({
+  id: z19.string(),
   /** e.g. `settings.json` — the file's own name, since the folder is shown once on the account. */
-  label: z18.string(),
+  label: z19.string(),
   /** Absolute, resolved inside this account's config folder. */
-  path: z18.string(),
-  exists: z18.boolean()
+  path: z19.string(),
+  exists: z19.boolean()
 });
-var agentProfileSchema = z18.object({
+var agentProfileSchema = z19.object({
   /** `default` for the discovered profile, else the stored slug. */
-  id: z18.string(),
+  id: z19.string(),
   provider: providerIdSchema,
-  label: z18.string(),
+  label: z19.string(),
   /** As the user wrote it — a literal `~` is preserved, matching `browseRoot`/`projectsDir`. */
-  configDir: z18.string(),
+  configDir: z19.string(),
   /** Expanded absolute path. Same-origin route, like `ProjectListEntry.root`. */
-  path: z18.string(),
+  path: z19.string(),
   /** False for a dir the CLI has not created yet — legitimate, and NOT a reason to fall back
    *  to another account at run time (that would silently bill the wrong subscription). */
-  exists: z18.boolean(),
+  exists: z19.boolean(),
   /** Whether the dir carries this agent's own marker files. ADVISORY: an unrecognised dir is
    *  still accepted, because "add profile → Connect → the CLI creates it" is the real flow. */
-  looksValid: z18.boolean(),
+  looksValid: z19.boolean(),
   /** True for the profile cezar discovers from the environment. Never stored, never deletable. */
-  isDefault: z18.boolean(),
+  isDefault: z19.boolean(),
   /** This account's own authentication state — two Claude logins answer independently.
    *
    *  **Absent until the probe has warmed.** Every probe shells out to an agent CLI, and this
@@ -2382,36 +2789,37 @@ var agentProfileSchema = z18.object({
   status: providerStatusSchema.optional(),
   /** This agent's own user-scope config files, resolved inside THIS account's folder — so a
    *  second login's `settings.json` is the one you open, not the default account's. */
-  files: z18.array(agentAccountFileSchema)
+  files: z19.array(agentAccountFileSchema)
 });
 function agentAccountRouteId(profile) {
   return profile.isDefault ? `default:${profile.provider}` : profile.id;
 }
-var agentAccountSelectionSchema = z18.object({
-  claude: z18.string().optional(),
-  codex: z18.string().optional(),
-  opencode: z18.string().optional(),
-  pi: z18.string().optional(),
-  cursor: z18.string().optional()
-});
-var agentProfilesResponseSchema = z18.object({
-  editable: z18.boolean(),
-  profiles: z18.array(agentProfileSchema),
+var agentAccountSelectionSchema = z19.object({
+  claude: z19.string().optional(),
+  codex: z19.string().optional(),
+  opencode: z19.string().optional(),
+  pi: z19.string().optional(),
+  cursor: z19.string().optional(),
+  omp: z19.string().optional()
+});
+var agentProfilesResponseSchema = z19.object({
+  editable: z19.boolean(),
+  profiles: z19.array(agentProfileSchema),
   /** Providers that can carry more than one account at all — what "Add account" is offered for.
    *  OpenCode is absent: its credentials live in a SQLite DB behind a separate `OPENCODE_DB`, so
    *  a config-dir profile would swap settings while still billing the other account. */
-  profileCapableProviders: z18.array(providerIdSchema),
+  profileCapableProviders: z19.array(providerIdSchema),
   /** Which account each project uses, keyed by the project's realpath'd ROOT.
    *
    *  Served here rather than on `GET /api/v1/projects` because it is stored beside the accounts it
    *  names (`~/.cezar/agent-accounts.json`) — one file, so deleting an account and scrubbing every
    *  reference to it is one atomic write, and neither can be dropped by a cezar version that never
    *  heard of accounts. Empty in hosted mode, where the whole family is withheld. */
-  selections: z18.record(z18.string(), agentAccountSelectionSchema),
+  selections: z19.record(z19.string(), agentAccountSelectionSchema),
   /** The machine-wide fallback account per provider, used by any repo that has chosen none. */
   defaults: agentAccountSelectionSchema
 });
-var selectAgentProfileInputSchema = z18.object({
+var selectAgentProfileInputSchema = z19.object({
   /**
    * Registry slug, or the reserved `default` boot alias. Resolved to a root server-side.
    *
@@ -2419,108 +2827,325 @@ var selectAgentProfileInputSchema = z18.object({
    * chosen nothing uses, so a second login is set up once rather than per checkout. A repo's own
    * choice always wins over it, which is what keeps this a default and not an override.
    */
-  projectId: z18.string().min(1).max(64).nullable(),
+  projectId: z19.string().min(1).max(64).nullable(),
   provider: providerIdSchema,
-  profileId: z18.string().max(64).nullable()
+  profileId: z19.string().max(64).nullable()
 });
-var agentProfileSelectionsResponseSchema = z18.object({
-  selections: z18.record(z18.string(), agentAccountSelectionSchema),
+var agentProfileSelectionsResponseSchema = z19.object({
+  selections: z19.record(z19.string(), agentAccountSelectionSchema),
   /** The machine-wide fallback, for repos with no selection of their own. */
   defaults: agentAccountSelectionSchema
 });
-var agentAccountStatusResponseSchema = z18.object({ status: providerStatusSchema });
-var agentAccountDetailsResponseSchema = z18.object({
-  available: z18.boolean(),
-  reason: z18.string().optional(),
-  fields: z18.array(z18.object({ label: z18.string(), value: z18.string() }))
+var agentAccountStatusResponseSchema = z19.object({ status: providerStatusSchema });
+var agentAccountDetailsResponseSchema = z19.object({
+  available: z19.boolean(),
+  reason: z19.string().optional(),
+  fields: z19.array(z19.object({ label: z19.string(), value: z19.string() }))
 });
-var openAgentAccountFileInputSchema = z18.object({
-  file: z18.string().min(1).max(200),
-  target: z18.string().min(1).max(64).optional()
+var openAgentAccountFileInputSchema = z19.object({
+  file: z19.string().min(1).max(200),
+  target: z19.string().min(1).max(64).optional()
 });
-var openAgentAccountFileResponseSchema = z18.object({
-  opened: z18.literal(true),
-  path: z18.string()
+var openAgentAccountFileResponseSchema = z19.object({
+  opened: z19.literal(true),
+  path: z19.string()
 });
-var createAgentProfileInputSchema = z18.object({
+var createAgentProfileInputSchema = z19.object({
   provider: providerIdSchema,
-  label: z18.string().trim().max(200).optional(),
+  label: z19.string().trim().max(200).optional(),
   /** Stored as written; validated absolute after `~` expansion, server-side. */
-  configDir: z18.string().trim().min(1).max(4096)
+  configDir: z19.string().trim().min(1).max(4096)
 });
-var agentProfileResponseSchema = z18.object({ profile: agentProfileSchema });
-var updateAgentProfileInputSchema = z18.object({
-  label: z18.string().trim().max(200).optional(),
-  configDir: z18.string().trim().min(1).max(4096).optional()
+var agentProfileResponseSchema = z19.object({ profile: agentProfileSchema });
+var updateAgentProfileInputSchema = z19.object({
+  label: z19.string().trim().max(200).optional(),
+  configDir: z19.string().trim().min(1).max(4096).optional()
 });
-var removeAgentProfileResponseSchema = z18.object({
-  removed: z18.literal(true),
-  id: z18.string()
+var removeAgentProfileResponseSchema = z19.object({
+  removed: z19.literal(true),
+  id: z19.string()
 });
 
+// ../contract/src/zoned-time.ts
+var formatters = /* @__PURE__ */ new Map();
+function formatter(timeZone) {
+  let cached = formatters.get(timeZone);
+  if (!cached) {
+    cached = new Intl.DateTimeFormat("en-CA", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+    formatters.set(timeZone, cached);
+  }
+  return cached;
+}
+function zonedParts(utcMs, timeZone) {
+  try {
+    const parts = formatter(timeZone).formatToParts(new Date(utcMs));
+    const value = (type) => Number(parts.find((part) => part.type === type)?.value);
+    const year = value("year");
+    const month = value("month");
+    const day = value("day");
+    const hour = value("hour") % 24;
+    return {
+      year,
+      month,
+      day,
+      hour,
+      minute: value("minute"),
+      second: value("second"),
+      weekday: isoWeekday(year, month, day)
+    };
+  } catch {
+    return null;
+  }
+}
+function isoWeekday(year, month, day) {
+  const dow = new Date(Date.UTC(year, month - 1, day)).getUTCDay();
+  return (dow + 6) % 7 + 1;
+}
+function timeZoneOffsetMs(timeZone, utcMs) {
+  const parts = zonedParts(utcMs, timeZone);
+  if (!parts) return null;
+  const asUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+  return asUtc - utcMs;
+}
+function zonedWallTimeToUtc(year, month, day, hour, minute, timeZone) {
+  const wallAsUtc = Date.UTC(year, month - 1, day, hour, minute, 0, 0);
+  let candidate = wallAsUtc;
+  for (let i = 0; i < 3; i += 1) {
+    const offset = timeZoneOffsetMs(timeZone, candidate);
+    if (offset === null) return null;
+    const next = wallAsUtc - offset;
+    if (Math.abs(next - candidate) < 1e3) return next;
+    candidate = next;
+  }
+  return candidate;
+}
+function isValidTimeZone(candidate) {
+  if (!candidate) return false;
+  try {
+    formatter(candidate).format(/* @__PURE__ */ new Date(0));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function localTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+// ../contract/src/automation-schedule.ts
+import { z as z20 } from "zod";
+var SCHEDULE_TYPES = ["daily", "weekdays", "weekly", "hours"];
+var SCHEDULE_HOURS_OPTIONS = [1, 2, 3, 4, 6, 8, 12];
+var WEEKDAY_NAMES = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+var WEEKDAY_LONG = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+var automationScheduleSchema = z20.object({
+  type: z20.enum(SCHEDULE_TYPES),
+  /** 0–23; `daily`, `weekdays`, `weekly`. Default 4. */
+  hour: z20.number().int().min(0).max(23).optional(),
+  /** 0–59; `daily`, `weekdays`, `weekly`. Default 0. */
+  minute: z20.number().int().min(0).max(59).optional(),
+  /** ISO weekday, Monday = 1 … Sunday = 7; `weekly`. Default 1. */
+  day: z20.number().int().min(1).max(7).optional(),
+  /** Hours between runs, from 00:00; `hours`. Default 6. */
+  every: z20.union([
+    z20.literal(1),
+    z20.literal(2),
+    z20.literal(3),
+    z20.literal(4),
+    z20.literal(6),
+    z20.literal(8),
+    z20.literal(12)
+  ]).optional()
+});
+function normalizeSchedule(schedule) {
+  return {
+    type: schedule.type,
+    hour: schedule.hour ?? 4,
+    minute: schedule.minute ?? 0,
+    day: schedule.day ?? 1,
+    every: schedule.every ?? 6
+  };
+}
+var pad = (n) => String(n).padStart(2, "0");
+function hm(hour, minute = 0) {
+  return `${pad(hour)}:${pad(minute)}`;
+}
+function scheduleLabel(schedule) {
+  const s = normalizeSchedule(schedule);
+  switch (s.type) {
+    case "daily":
+      return `every day at ${hm(s.hour, s.minute)}`;
+    case "weekdays":
+      return `weekdays at ${hm(s.hour, s.minute)}`;
+    case "hours":
+      return s.every === 1 ? "every hour" : `every ${s.every} hours`;
+    case "weekly":
+      return `${WEEKDAY_LONG[s.day - 1]}s at ${hm(s.hour, s.minute)}`;
+  }
+}
+function cronOf(schedule) {
+  const s = normalizeSchedule(schedule);
+  switch (s.type) {
+    case "daily":
+      return `${s.minute} ${s.hour} * * *`;
+    case "weekdays":
+      return `${s.minute} ${s.hour} * * 1-5`;
+    case "hours":
+      return `0 */${s.every} * * *`;
+    case "weekly":
+      return `${s.minute} ${s.hour} * * ${s.day % 7}`;
+  }
+}
+function parseCron(expression) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5) return null;
+  const [minuteField, hourField, dom, month, dow] = fields;
+  if (dom !== "*" || month !== "*") return null;
+  const hoursEvery = /^\*\/(\d+)$/.exec(hourField);
+  if (hoursEvery && minuteField === "0" && dow === "*") {
+    const every = Number(hoursEvery[1]);
+    return SCHEDULE_HOURS_OPTIONS.includes(every) ? { type: "hours", every } : null;
+  }
+  if (!/^\d{1,2}$/.test(minuteField) || !/^\d{1,2}$/.test(hourField)) return null;
+  const minute = Number(minuteField);
+  const hour = Number(hourField);
+  if (minute > 59 || hour > 23) return null;
+  if (dow === "*") return { type: "daily", hour, minute };
+  if (dow === "1-5") return { type: "weekdays", hour, minute };
+  if (/^[0-7]$/.test(dow)) {
+    const cronDay = Number(dow);
+    const day = cronDay === 0 ? 7 : cronDay;
+    return { type: "weekly", hour, minute, day };
+  }
+  return null;
+}
+function wallTimesOn(s, weekday) {
+  switch (s.type) {
+    case "daily":
+      return [[s.hour, s.minute]];
+    case "weekdays":
+      return weekday <= 5 ? [[s.hour, s.minute]] : [];
+    case "weekly":
+      return weekday === s.day ? [[s.hour, s.minute]] : [];
+    case "hours": {
+      const out = [];
+      for (let h = 0; h < 24; h += s.every) out.push([h, 0]);
+      return out;
+    }
+  }
+}
+function occurrencesBetween(schedule, fromMs, toMs, timeZone, limit = 1e3) {
+  const s = normalizeSchedule(schedule);
+  const start = zonedParts(fromMs, timeZone);
+  if (!start || toMs <= fromMs) return [];
+  const out = [];
+  const dayCount = Math.ceil((toMs - fromMs) / 864e5) + 2;
+  for (let d = -1; d <= dayCount; d += 1) {
+    const date = new Date(Date.UTC(start.year, start.month - 1, start.day + d));
+    const year = date.getUTCFullYear();
+    const month = date.getUTCMonth() + 1;
+    const day = date.getUTCDate();
+    for (const [hour, minute] of wallTimesOn(s, isoWeekday(year, month, day))) {
+      const at = zonedWallTimeToUtc(year, month, day, hour, minute, timeZone);
+      if (at === null) return out;
+      if (at === out.at(-1)) continue;
+      if (at >= fromMs && at < toMs) {
+        out.push(at);
+        if (out.length >= limit) return out;
+      }
+    }
+  }
+  return out;
+}
+function nextOccurrence(schedule, afterMs, timeZone) {
+  const [first] = occurrencesBetween(schedule, afterMs + 1, afterMs + 9 * 864e5, timeZone, 1);
+  return first ?? null;
+}
+
 // ../contract/src/automations.ts
-import { z as z19 } from "zod";
-var automationEventSchema = z19.enum([
+import { z as z21 } from "zod";
+var automationEventSchema = z21.enum([
   "pull_request.opened",
   "issue.opened",
   "issue.labeled",
   "issue.unlabeled"
 ]);
-var automationFiltersSchema = z19.object({
-  authors: z19.array(z19.string()).optional(),
-  assignees: z19.array(z19.string()).optional(),
-  allLabels: z19.array(z19.string()).optional(),
-  anyLabels: z19.array(z19.string()).optional(),
-  excludeLabels: z19.array(z19.string()).optional(),
+var automationFiltersSchema = z21.object({
+  authors: z21.array(z21.string()).optional(),
+  assignees: z21.array(z21.string()).optional(),
+  allLabels: z21.array(z21.string()).optional(),
+  anyLabels: z21.array(z21.string()).optional(),
+  excludeLabels: z21.array(z21.string()).optional(),
   /** Required for the two label events — the server rejects a definition without it. */
-  changedLabels: z19.array(z19.string()).optional(),
-  lookbackDays: z19.number(),
-  maxRecords: z19.number()
+  changedLabels: z21.array(z21.string()).optional(),
+  lookbackDays: z21.number(),
+  maxRecords: z21.number()
 });
+var automationKindSchema = z21.enum(["github", "schedule"]);
 var automationTaskSchema = createRunInputBaseSchema.omit({ task: true, images: true, todoId: true, systemPrompt: true }).extend({
   /** The prompt template. `{{github.number}}`, `{{github.title}}`, `{{github.url}}` and
    *  `{{github.labels}}` are substituted per match; GitHub content is appended as untrusted
    *  context, never interpolated into instructions. */
-  prompt: z19.string(),
-  variants: z19.union([z19.literal(1), z19.literal(2), z19.literal(3)]).optional(),
-  systemPrompt: z19.string().optional()
+  prompt: z21.string(),
+  variants: z21.union([z21.literal(1), z21.literal(2), z21.literal(3)]).optional(),
+  systemPrompt: z21.string().optional()
 });
-var automationDefinitionSchema = z19.object({
-  id: z19.string(),
+var automationDefinitionSchema = z21.object({
+  id: z21.string(),
   /** Bumped on every edit; a PUT must echo the revision it read (optimistic concurrency). */
-  revision: z19.number(),
-  name: z19.string(),
-  description: z19.string().optional(),
+  revision: z21.number(),
+  name: z21.string(),
+  description: z21.string().optional(),
   /** Always present: the storage schema defaults it to `false`, so a definition is created
    *  PAUSED and enabling it is a separate, baseline-establishing act. */
-  enabled: z19.boolean(),
-  events: z19.array(automationEventSchema),
-  intervalSeconds: z19.number(),
-  filters: automationFiltersSchema,
+  enabled: z21.boolean(),
+  kind: automationKindSchema,
+  /** `github` kind: always present. `schedule` kind: absent. */
+  events: z21.array(automationEventSchema).optional(),
+  intervalSeconds: z21.number().optional(),
+  filters: automationFiltersSchema.optional(),
+  /** `schedule` kind: always present. `github` kind: absent. */
+  schedule: automationScheduleSchema.optional(),
   task: automationTaskSchema,
-  createdAt: z19.string(),
-  updatedAt: z19.string()
+  createdAt: z21.string(),
+  updatedAt: z21.string()
 });
-var automationCursorSchema = z19.object({
-  timestamp: z19.string(),
-  tieBreaker: z19.string().optional()
+var automationCursorSchema = z21.object({
+  timestamp: z21.string(),
+  tieBreaker: z21.string().optional()
 });
-var automationRuntimeStateSchema = z19.object({
+var automationRuntimeStateSchema = z21.object({
   /** The definition revision this state belongs to; a bumped revision re-baselines. */
-  revision: z19.number().optional(),
+  revision: z21.number().optional(),
   /** Enabling establishes a CURRENT-TIME baseline: records older than this never launch. */
-  baselineAt: z19.string().optional(),
+  baselineAt: z21.string().optional(),
   cursor: automationCursorSchema.optional(),
-  frozenHighWatermark: automationCursorSchema.extend({ tieBreaker: z19.string() }).optional(),
-  backlogAfter: automationCursorSchema.extend({ tieBreaker: z19.string() }).optional(),
-  nextCheckAt: z19.string().optional(),
-  lastSuccessAt: z19.string().optional(),
+  frozenHighWatermark: automationCursorSchema.extend({ tieBreaker: z21.string() }).optional(),
+  backlogAfter: automationCursorSchema.extend({ tieBreaker: z21.string() }).optional(),
+  nextCheckAt: z21.string().optional(),
+  lastSuccessAt: z21.string().optional(),
+  /** `schedule` kind: the next occurrence's instant and the last fired one's. */
+  nextRunAt: z21.string().optional(),
+  lastRunAt: z21.string().optional(),
   /** Per-query GitHub ETags, so an unchanged page costs no rate-limit budget. */
-  etags: z19.record(z19.string(), z19.string()).optional(),
-  backoffUntil: z19.string().optional(),
-  consecutiveFailures: z19.number().optional()
+  etags: z21.record(z21.string(), z21.string()).optional(),
+  backoffUntil: z21.string().optional(),
+  consecutiveFailures: z21.number().optional()
 });
-var automationLogResultSchema = z19.enum([
+var automationLogResultSchema = z21.enum([
   "launched",
   "no-match",
   "duplicate",
@@ -2528,116 +3153,136 @@ var automationLogResultSchema = z19.enum([
   "error",
   "baseline",
   "preview",
-  "skipped"
+  "skipped",
+  // schedule kind: a Run now launch, a missed occurrence fired once after a gap, a launch that threw.
+  "manual",
+  "catch-up",
+  "failed"
 ]);
-var automationLogRecordSchema = z19.object({
-  seq: z19.number(),
-  ts: z19.string(),
-  automationId: z19.string(),
-  revision: z19.number(),
+var automationLogRecordSchema = z21.object({
+  seq: z21.number(),
+  ts: z21.string(),
+  automationId: z21.string(),
+  revision: z21.number(),
   event: automationEventSchema.optional(),
   result: automationLogResultSchema,
-  reason: z19.string().optional(),
-  durationMs: z19.number().optional(),
-  receiptId: z19.string().optional(),
-  runId: z19.string().optional(),
-  githubNumber: z19.number().optional(),
-  githubTitle: z19.string().optional(),
-  githubUrl: z19.string().optional(),
-  rateLimit: z19.object({
-    bucket: z19.enum(["core", "search"]),
-    remaining: z19.number().optional(),
-    resetAt: z19.string().optional()
+  reason: z21.string().optional(),
+  durationMs: z21.number().optional(),
+  receiptId: z21.string().optional(),
+  runId: z21.string().optional(),
+  githubNumber: z21.number().optional(),
+  githubTitle: z21.string().optional(),
+  githubUrl: z21.string().optional(),
+  rateLimit: z21.object({
+    bucket: z21.enum(["core", "search"]),
+    remaining: z21.number().optional(),
+    resetAt: z21.string().optional()
   }).optional()
 });
-var automationCountsSchema = z19.object({
-  matches: z19.number(),
-  launched: z19.number(),
-  duplicates: z19.number(),
-  errors: z19.number()
+var automationCountsSchema = z21.object({
+  /** GitHub candidates that matched a filter: `launched` + `duplicate` rows. */
+  matches: z21.number(),
+  /** Tasks launched: `launched`, plus a schedule's `manual` (Run now) and `catch-up` rows. */
+  launched: z21.number(),
+  /** `duplicate` rows: a match whose receipt already existed, so nothing launched. */
+  duplicates: z21.number(),
+  /** `error` and `rate-limited` rows, plus a schedule's `failed` launches. */
+  errors: z21.number()
 });
 var automationListEntrySchema = automationDefinitionSchema.extend({
   state: automationRuntimeStateSchema.optional(),
   latestLog: automationLogRecordSchema.optional(),
-  counts: automationCountsSchema
-});
-var automationsResponseSchema = z19.object({
-  available: z19.boolean(),
-  reason: z19.string().optional(),
-  scheduler: z19.object({
-    state: z19.enum(["scheduled", "idle"]),
-    nextDue: z19.string().optional()
+  counts: automationCountsSchema,
+  /** Enabled only: a schedule's armed `state.nextRunAt`, a poll's `state.nextCheckAt`. Absent
+   *  while paused, and for a schedule the timer has not armed yet. */
+  nextRunAt: z21.string().optional()
+});
+var automationsResponseSchema = z21.object({
+  available: z21.boolean(),
+  reason: z21.string().optional(),
+  timeZone: z21.string(),
+  scheduler: z21.object({
+    state: z21.enum(["scheduled", "idle"]),
+    nextDue: z21.string().optional()
   }),
-  automations: z19.array(automationListEntrySchema)
+  automations: z21.array(automationListEntrySchema)
 });
-var automationResponseSchema = z19.object({ automation: automationDefinitionSchema });
-var automationDetailResponseSchema = z19.object({
+var automationResponseSchema = z21.object({ automation: automationDefinitionSchema });
+var automationDetailResponseSchema = z21.object({
   automation: automationDefinitionSchema,
   state: automationRuntimeStateSchema.optional(),
   latestLog: automationLogRecordSchema.optional()
 });
-var automationCheckSchema = z19.object({
-  id: z19.string(),
-  automationId: z19.string(),
-  mode: z19.enum(["preview", "execute"]),
-  status: z19.enum(["queued", "running", "complete", "error"]),
-  createdAt: z19.string(),
-  completedAt: z19.string().optional(),
-  matches: z19.number().optional(),
-  truncated: z19.boolean().optional(),
-  error: z19.string().optional()
-});
-var automationCheckQueuedResponseSchema = z19.object({ checkId: z19.string() });
-var automationLogResponseSchema = z19.object({
-  records: z19.array(automationLogRecordSchema)
-});
-var automationRetryResponseSchema = z19.object({
-  receiptId: z19.string(),
-  runId: z19.string()
-});
-var createAutomationInputSchema = automationDefinitionSchema.omit({ id: true, revision: true, createdAt: true, updatedAt: true, enabled: true }).extend({ enable: z19.boolean().optional() });
+var automationCheckSchema = z21.object({
+  id: z21.string(),
+  automationId: z21.string(),
+  mode: z21.enum(["preview", "execute"]),
+  status: z21.enum(["queued", "running", "complete", "error"]),
+  createdAt: z21.string(),
+  completedAt: z21.string().optional(),
+  matches: z21.number().optional(),
+  truncated: z21.boolean().optional(),
+  error: z21.string().optional()
+});
+var automationCheckQueuedResponseSchema = z21.object({ checkId: z21.string() });
+var automationLogResponseSchema = z21.object({
+  records: z21.array(automationLogRecordSchema)
+});
+var automationRetryResponseSchema = z21.object({
+  receiptId: z21.string(),
+  runId: z21.string()
+});
+var automationRunResponseSchema = z21.object({ runId: z21.string() });
+var createAutomationInputSchema = automationDefinitionSchema.omit({ id: true, revision: true, createdAt: true, updatedAt: true, enabled: true, kind: true }).extend({
+  /** Omitted = `github` on create, the shape every pre-schedule client sends; omitted on
+   *  update = the stored kind. */
+  kind: automationKindSchema.optional(),
+  enable: z21.boolean().optional()
+});
 var updateAutomationInputSchema = createAutomationInputSchema.omit({ enable: true }).extend({
-  enabled: z19.boolean().optional(),
-  expectedRevision: z19.number()
+  enabled: z21.boolean().optional(),
+  expectedRevision: z21.number()
 });
-var automationCheckInputSchema = z19.object({
-  mode: z19.enum(["preview", "execute"])
+var automationCheckInputSchema = z21.object({
+  mode: z21.enum(["preview", "execute"])
 });
 
 // ../contract/src/artifacts.ts
-import { z as z20 } from "zod";
-var pathSchema = z20.string().min(1).max(8192).refine((value) => !value.includes("\0"), "Path contains NUL");
-var publishedArtifactSchema = z20.object({
-  id: z20.uuid(),
-  runId: z20.uuid(),
-  name: z20.string().min(1).max(255),
+import { z as z22 } from "zod";
+var pathSchema = z22.string().min(1).max(8192).refine((value) => !value.includes("\0"), "Path contains NUL");
+var publishedArtifactSchema = z22.object({
+  id: z22.uuid(),
+  runId: z22.uuid(),
+  name: z22.string().min(1).max(255),
   sourcePath: pathSchema.refine((value) => /^(?:\/|[A-Za-z]:[\\/]|\\\\)/.test(value), "Expected an absolute source path"),
-  createdAt: z20.iso.datetime(),
-  size: z20.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  sha256: z20.string().regex(/^[a-f0-9]{64}$/)
+  createdAt: z22.iso.datetime(),
+  size: z22.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  sha256: z22.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var filePreviewDataSchema = z20.object({
-  type: z20.literal("file"),
+var filePreviewDataSchema = z22.object({
+  type: z22.literal("file"),
   path: pathSchema,
-  size: z20.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  binary: z20.boolean(),
-  tooLarge: z20.boolean(),
-  content: z20.string().optional(),
-  source: z20.enum(["worktree", "project", "artifact"]),
+  size: z22.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  binary: z22.boolean(),
+  tooLarge: z22.boolean(),
+  content: z22.string().optional(),
+  source: z22.enum(["worktree", "project", "artifact"]),
   artifact: publishedArtifactSchema.optional()
 }).strict();
-var fileLinkResultSchema = z20.union([
+var fileLinkResultSchema = z22.union([
   filePreviewDataSchema,
-  z20.object({
-    type: z20.enum(["unavailable", "unpublished"]),
+  z22.object({
+    type: z22.enum(["unavailable", "unpublished"]),
     path: pathSchema,
-    reason: z20.string().min(1).max(4096)
+    reason: z22.string().min(1).max(4096)
   }).strict()
 ]);
-var artifactListSchema = z20.object({ artifacts: z20.array(publishedArtifactSchema).max(64) }).strict();
-var fileLinkQuerySchema = z20.object({ path: pathSchema, raw: z20.literal("1").optional() }).strict();
-var artifactParamsSchema = z20.object({ id: z20.uuid(), artifactId: z20.uuid() });
+var artifactListSchema = z22.object({ artifacts: z22.array(publishedArtifactSchema).max(64) }).strict();
+var fileLinkQuerySchema = z22.object({ path: pathSchema, raw: z22.literal("1").optional() }).strict();
+var artifactParamsSchema = z22.object({ id: z22.uuid(), artifactId: z22.uuid() });
 export {
+  ARCHIVED_RUNS_PAGE_DEFAULT,
+  ARCHIVED_RUNS_PAGE_MAX,
   ATTENTION_RANK,
   CI_WAIT_LIMITATION,
   CI_WAIT_RECEIPT_INSTRUCTION,
@@ -2652,7 +3297,15 @@ export {
   PROJECT_WEBHOOK_TOKEN_MAX_LENGTH,
   PROJECT_WEBHOOK_URL_MAX_LENGTH,
   REFERENCE_STATUS_MAX,
+  RUNS_SEARCH_PER_PROJECT_MAX,
   RUN_HISTORY_PAGE_ITEMS,
+  SCHEDULE_HOURS_OPTIONS,
+  SCHEDULE_TYPES,
+  WEEKDAY_NAMES,
+  WORKTREE_SETUP_DEFAULT_TIMEOUT_SECONDS,
+  WORKTREE_SETUP_MAX_COMMANDS,
+  WORKTREE_SETUP_MAX_COMMAND_LENGTH,
+  WORKTREE_SETUP_MAX_TIMEOUT_SECONDS,
   advancePendingHumanAsk,
   agentAccountDetailsResponseSchema,
   agentAccountFileSchema,
@@ -2676,7 +3329,11 @@ export {
   applicationUpdateInputSchema,
   applicationUpdateResponseSchema,
   applicationUpdateStateSchema,
+  archiveFinishedRequestSchema,
   archiveFinishedResponseSchema,
+  archiveFinishedScopeSchema,
+  archivedRunsQuerySchema,
+  archivedRunsResponseSchema,
   artifactListSchema,
   artifactParamsSchema,
   askOptionSchema,
@@ -2694,13 +3351,16 @@ export {
   automationDetailResponseSchema,
   automationEventSchema,
   automationFiltersSchema,
+  automationKindSchema,
   automationListEntrySchema,
   automationLogRecordSchema,
   automationLogResponseSchema,
   automationLogResultSchema,
   automationResponseSchema,
   automationRetryResponseSchema,
+  automationRunResponseSchema,
   automationRuntimeStateSchema,
+  automationScheduleSchema,
   automationTaskSchema,
   automationsResponseSchema,
   backendCheckSchema,
@@ -2741,6 +3401,7 @@ export {
   createRunInputBaseSchema,
   createRunInputSchema,
   createRunResponseSchema,
+  cronOf,
   delegationErrorResponseSchema,
   delegationStateSchema,
   delegationWaitLabel,
@@ -2792,6 +3453,7 @@ export {
   groupResponseSchema,
   groupVariantSchema,
   healthResponseSchema,
+  hm,
   humanInputDeliveredEventSchema,
   imageInputSchema,
   importableSkillSchema,
@@ -2802,7 +3464,10 @@ export {
   isAttachmentMediaType,
   isImageAttachmentName,
   isImageMediaType,
+  isValidTimeZone,
+  isoWeekday,
   launchKeyResponseSchema,
+  localTimeZone,
   logEntrySchema,
   logEntrySourceSchema,
   markAllReadResponseSchema,
@@ -2810,7 +3475,11 @@ export {
   messageResponseSchema,
   modelChoicesSchema,
   modelDiscoveryRunnerSchema,
+  nextOccurrence,
+  normalizeSchedule,
+  normalizeSidebarLimits,
   notifyRunInputSchema,
+  occurrencesBetween,
   openAgentAccountFileInputSchema,
   openAgentAccountFileResponseSchema,
   openInCliResponseSchema,
@@ -2818,6 +3487,7 @@ export {
   openProjectInSchema,
   openTargetSchema,
   openTargetsResponseSchema,
+  parseCron,
   parseEffort,
   parsedWorkflowSchema,
   patchRunInputSchema,
@@ -2825,6 +3495,19 @@ export {
   pickVariantResponseSchema,
   pinRunInputSchema,
   planResponseSchema,
+  previewClientMessageSchema,
+  previewKeyTypeSchema,
+  previewMouseButtonSchema,
+  previewMouseTypeSchema,
+  previewResultCodeSchema,
+  previewServeRequestSchema,
+  previewServeResultSchema,
+  previewServerMessageSchema,
+  previewServerSchema,
+  previewServerStateSchema,
+  previewStateMessageSchema,
+  previewStopRequestSchema,
+  previewStopResultSchema,
   processUsageSchema,
   projectListEntrySchema,
   projectWebhookInputSchema,
@@ -2843,6 +3526,7 @@ export {
   referenceStatusSchema,
   referenceStatusesByProjectSchema,
   registerProjectResponseSchema,
+  relatedRunTitleSchema,
   removeAgentProfileResponseSchema,
   removeProjectResponseSchema,
   removeQueuedMessageResponseSchema,
@@ -2879,21 +3563,29 @@ export {
   runRecordSchema,
   runRelationshipsSchema,
   runStatusSchema,
+  runSummariesQuerySchema,
+  runSummarySchema,
   runWebhookOutcomeSchema,
+  runWorkflowLabel,
+  runWorktreeSetupSchema,
   runnerDiscoversModels,
   runnerModelCatalogResponseSchema,
   runnerModelOptionSchema,
   runnerModelsSchema,
   runnerSchema,
   runsIndexResponseSchema,
+  runsSearchQuerySchema,
+  runsSearchResponseSchema,
   saveWorkflowInputSchema,
   saveWorkflowResponseSchema,
+  scheduleLabel,
   selectAgentProfileInputSchema,
   setAgentConfigInputSchema,
   setConfigInputSchema,
   setConfigResponseSchema,
   setWorkspaceConfigInputSchema,
   setWorkspaceUiStateInputSchema,
+  sidebarLimitsSchema,
   skillSchema,
   skillsUpdateScopeStateSchema,
   skillsUpdateStateSchema,
@@ -2903,6 +3595,8 @@ export {
   stepStateSchema,
   stepStatusSchema,
   testProjectWebhookResponseSchema,
+  timeZoneOffsetMs,
+  toRunSummary,
   todoItemSchema,
   uiStateSchema,
   updateAgentProfileInputSchema,
@@ -2913,12 +3607,15 @@ export {
   workerBackendSchema,
   workerCancelWaitRequestSchema,
   workerCancelWaitResultSchema,
+  workerCapacitySchema,
   workerCollectedResultSchema,
   workerContextReferenceSchema,
   workerContextSchema,
   workerCreationReceiptSchema,
   workerDestroyResultSchema,
+  workerDestroyRetrySchema,
   workerDestroySchema,
+  workerDestroyViewSchema,
   workerDiffSchema,
   workerEmptyRequestSchema,
   workerInputRecipeSchema,
@@ -2952,5 +3649,8 @@ export {
   worktreeDirEntrySchema,
   worktreeEntrySchema,
   worktreeInfoSchema,
-  worktreesResponseSchema
+  worktreeSetupConfigSchema,
+  worktreesResponseSchema,
+  zonedParts,
+  zonedWallTimeToUtc
 };