@open-mercato/cezar 0.9.1 → 0.9.2

package/dist/contract/index.js

@@ -0,0 +1,1421 @@
+// ../contract/src/events.ts
+import { z } from "zod";
+var runEventSchema = z.looseObject({
+  seq: z.number(),
+  ts: z.string(),
+  stepId: z.string().optional(),
+  type: z.string()
+});
+var checkoutProgressEventSchema = z.object({
+  checkoutId: z.string().optional(),
+  name: z.string(),
+  phase: z.enum(["cloning", "done", "error"]),
+  line: z.string().optional(),
+  error: z.string().optional()
+});
+
+// ../contract/src/health.ts
+import { z as z2 } from "zod";
+var runnerSchema = z2.enum(["claude", "codex", "opencode"]);
+var repoInfoSchema = z2.object({
+  root: z2.string(),
+  branch: z2.string(),
+  remote: z2.string().optional()
+});
+var backendCheckSchema = z2.object({
+  name: z2.enum(["claude", "codex", "opencode", "gh", "git"]),
+  available: z2.boolean(),
+  version: z2.string().optional(),
+  hint: z2.string().optional()
+});
+var forgeInfoSchema = z2.object({
+  kind: z2.literal("github"),
+  /**
+   * Whether the forge is reachable — **absent until the availability probe has warmed**.
+   *
+   * Health must never pay a `gh` shell-out, so it serves whatever the cache holds. Absent means
+   * "not determined yet", which is not the same as `false`, and the cockpit renders the two
+   * differently. Declaring it required is what made an earlier hand-written mirror wrong.
+   */
+  available: z2.boolean().optional(),
+  reason: z2.string().optional()
+});
+var capabilitiesSchema = z2.object({
+  localHandoff: z2.boolean(),
+  followups: z2.boolean(),
+  singleProject: z2.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
+   * only.
+   *
+   * REQUIRED, because this server always sends it (`capabilities.ts` computes it from the env on
+   * every read) and this contract describes THIS server's wire. The DTO it replaces declared it
+   * optional so a newer cockpit could read an OLDER server, which is version skew a contract
+   * versioned in lockstep with the server cannot model. That tolerance lives where it belongs, in
+   * `web/src/lib/token-metrics.ts`, whose `!== false` read still treats an absent field as
+   * visible.
+   */
+  tokenMetrics: z2.boolean(),
+  /** Current token-count presentation policy. Required on current servers;
+   * older payload tolerance belongs in the browser resolver. */
+  tokenUsageMetrics: z2.boolean(),
+  /** Current backend-reported-cost presentation policy. */
+  costMetrics: z2.boolean()
+});
+var healthResponseSchema = z2.object({
+  version: z2.string(),
+  latestVersion: z2.string().optional(),
+  repoRoot: z2.string(),
+  repo: repoInfoSchema.nullable(),
+  checks: z2.array(backendCheckSchema),
+  defaultRunner: runnerSchema,
+  forge: forgeInfoSchema.nullable(),
+  capabilities: capabilitiesSchema,
+  // Always sent: `workspaceSummary()` returns both unconditionally, and an unreadable workspace
+  // degrades to `projects: []` rather than to an absent key. The hand-written DTO declared them
+  // optional, which was wider than the server has ever been.
+  projects: z2.array(z2.object({ id: z2.string(), name: z2.string() })),
+  bootProject: z2.string()
+});
+
+// ../contract/src/runs.ts
+import { z as z4 } from "zod";
+
+// ../contract/src/workflows.ts
+import { z as z3 } from "zod";
+var workflowStepDefSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string().optional(),
+  // agent step
+  prompt: z3.string().optional(),
+  skill: z3.string().optional(),
+  model: z3.string().optional(),
+  /** Per-step agent backend override (falls back to the task / config default). */
+  runner: runnerSchema.optional(),
+  allowedTools: z3.array(z3.string()).optional(),
+  bashAllowlist: z3.array(z3.string()).optional(),
+  // check step
+  command: z3.string().optional(),
+  onFail: z3.object({
+    retry: z3.string().min(1),
+    max: z3.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"
+});
+var workflowDefSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().optional(),
+  steps: z3.array(workflowStepDefSchema),
+  source: z3.enum(["built-in", "file"]),
+  /** Absent on built-ins — which is exactly what makes them undeletable. */
+  path: z3.string().optional()
+});
+var workflowLoadIssueSchema = z3.object({
+  path: z3.string(),
+  message: z3.string()
+});
+var workflowsResponseSchema = z3.object({
+  workflows: z3.array(workflowDefSchema),
+  issues: z3.array(workflowLoadIssueSchema)
+});
+var saveWorkflowInputSchema = z3.object({
+  name: z3.string().trim().min(1).max(80),
+  description: z3.string().max(2e3, "must be at most 2000 characters").optional(),
+  steps: z3.array(workflowStepDefSchema).min(1).max(8).optional(),
+  skills: z3.array(z3.string().trim().min(1)).min(1).max(8).optional(),
+  overwrite: z3.boolean().optional()
+}).refine((b) => Boolean(b.steps) !== Boolean(b.skills), {
+  message: 'provide either "steps" or "skills", not both'
+});
+var saveWorkflowResponseSchema = z3.object({
+  path: z3.string(),
+  name: z3.string()
+});
+var parsedWorkflowSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().optional(),
+  steps: z3.array(workflowStepDefSchema)
+});
+var deleteWorkflowResponseSchema = z3.object({
+  ok: z3.literal(true),
+  path: z3.string()
+});
+var planResponseSchema = z3.object({
+  /** The kebab-case workflow title the planner proposed. Absent on the degraded fallback. */
+  name: z3.string().optional(),
+  steps: z3.array(workflowStepDefSchema),
+  rationale: z3.string(),
+  fallback: z3.boolean()
+});
+
+// ../contract/src/runs.ts
+var runStatusSchema = z4.enum([
+  "queued",
+  "running",
+  "waiting",
+  "review",
+  "done",
+  "failed",
+  "cancelled"
+]);
+var runActivitySchema = z4.enum(["monitoring"]);
+var stepStatusSchema = z4.enum([
+  "pending",
+  "running",
+  "waiting",
+  "review",
+  "done",
+  "failed",
+  "cancelled",
+  "skipped"
+]);
+var usageCounterSchema = z4.number().finite().nonnegative();
+var stepStateSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  kind: z4.enum(["agent", "check"]),
+  status: stepStatusSchema,
+  iterations: z4.number(),
+  tokensUsed: z4.number(),
+  inputTokens: usageCounterSchema.optional(),
+  outputTokens: usageCounterSchema.optional(),
+  usageInvocationsStarted: usageCounterSchema.optional(),
+  usageInvocationsObserved: usageCounterSchema.optional(),
+  usageTurnsStarted: usageCounterSchema.optional(),
+  usageTurnsRecorded: usageCounterSchema.optional(),
+  usageInvocationEpoch: usageCounterSchema.optional(),
+  startedAt: z4.string().optional(),
+  finishedAt: z4.string().optional(),
+  error: z4.string().optional(),
+  /** Latest agent session id — `claude --resume <id>` and friends. */
+  sessionId: z4.string().optional(),
+  /** Backend that owns `sessionId`; absent on records written before backend affinity. */
+  backend: runnerSchema.optional(),
+  costUsd: z4.number().optional()
+});
+var diffStatSchema = z4.object({
+  adds: z4.number(),
+  dels: z4.number(),
+  files: z4.number(),
+  /** Additive since #751, and present ONLY when true: the numbers cover uncommitted work
+   *  alone, 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 the
+   *  checked-out 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: z4.boolean().optional()
+});
+var queuedMessageSchema = z4.object({
+  id: z4.string(),
+  text: z4.string(),
+  /** `/api/v1/runs/:id/images/…` URLs — attachments are persisted, never inlined. */
+  images: z4.array(z4.string()).optional(),
+  createdAt: z4.string()
+});
+var processUsageSchema = z4.object({
+  /** Sum of `%cpu` across the tree — can exceed 100 on multi-core work. */
+  cpuPct: z4.number(),
+  rssBytes: z4.number(),
+  procCount: z4.number()
+});
+var runRecordSchema = z4.object({
+  id: z4.string(),
+  title: z4.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: z4.string().optional(),
+  /** Refreshed on every turn-end; absent until the first turn ends (and on worktree-less runs). */
+  diffStat: diffStatSchema.optional(),
+  workflow: z4.string(),
+  task: z4.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: z4.array(queuedMessageSchema).optional(),
+  /** URLs of images attached to the initial task prompt (#image-display). */
+  taskImages: z4.array(z4.string()).optional(),
+  model: z4.string().optional(),
+  /** Normalized provider/model identity used for attribution and reproducible replay. */
+  modelIdentity: z4.string().optional(),
+  runner: runnerSchema.optional(),
+  /** Echo of the extra system prompt the run used (POST override or config default). */
+  systemPrompt: z4.string().optional(),
+  /** false when the run deliberately disabled follow-up todo generation. Absent means enabled. */
+  generateFollowups: z4.boolean().optional(),
+  /** Autonomous mode (#autonomous): the run never parks at `waiting` or the terminal `review`
+   *  gate. Absent = falsy = not autonomous. */
+  autonomous: z4.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
+   * it is there.
+   *
+   * `event` is a plain string rather than `automationEventSchema`: it is the event NAME the
+   * 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: z4.object({
+    automationId: z4.string(),
+    automationRevision: z4.number(),
+    receiptId: z4.string(),
+    event: z4.string(),
+    githubUrl: z4.string()
+  }).optional(),
+  status: runStatusSchema,
+  /** `monitoring` while `status === 'running'` and the agent is working on downstream work.
+   *  Absent on old runs; cleared on resume/end. */
+  activity: runActivitySchema.optional(),
+  /** Exact ISO-8601 deadline for the next automatic monitoring check. */
+  monitoringWakeAt: z4.string().optional(),
+  /** The current live monitoring epoch exhausted its 40 automatic checks. */
+  monitoringWakeCapReached: z4.boolean().optional(),
+  createdAt: z4.string(),
+  startedAt: z4.string().optional(),
+  finishedAt: z4.string().optional(),
+  tokensUsed: z4.number(),
+  inputTokens: usageCounterSchema.optional(),
+  outputTokens: usageCounterSchema.optional(),
+  costUsd: z4.number().optional(),
+  pullRequestUrl: z4.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: z4.string().optional(),
+  /** The PR/issue number this task is ABOUT (task auto-naming spec) — display tier only. */
+  prNumber: z4.number().optional(),
+  issueNumber: z4.number().optional(),
+  /** Server-side provenance: referenced-issue discovery currently owns `issueNumber`. */
+  referencedIssueNumberSeeded: z4.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: z4.enum(["user", "auto", "marker"]).optional(),
+  /** References the agent declared via CEZ:PR/CEZ:ISSUE markers — authoritative over the namer
+   *  for the matching kind. */
+  markerRefs: z4.object({ pr: z4.number().optional(), issue: z4.number().optional() }).optional(),
+  /** The referenced tier's working set (distinct PR URLs spotted, capped server-side). */
+  referencedPrCandidates: z4.array(z4.string()).optional(),
+  /** The issue this task is ABOUT (spec 2026-07-21-report-ref-discovery). Display-only. */
+  referencedIssueUrl: z4.string().optional(),
+  /** The referenced-issue working set, persisted like `referencedPrCandidates`. Capped. */
+  referencedIssueCandidates: z4.array(z4.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: z4.literal(false).optional(),
+  /** Absent for in-place runs and after an isolated worktree is removed. */
+  worktreePath: z4.string().optional(),
+  branch: z4.string().optional(),
+  /** Stable baseline for session git views: a worktree's fork ref, or an in-place run's starting commit. */
+  baseBranch: z4.string().optional(),
+  /** Set when count-based retention (#483) reclaimed the worktree DIRECTORY (the branch is
+   *  kept): the dir is gone but recoverable. */
+  worktreeReclaimedAt: z4.string().optional(),
+  /** Parallel variants (spec 010): runs sharing a groupId are one group. */
+  groupId: z4.string().optional(),
+  /** Variant letter within the group — 'A' | 'B' | 'C'. */
+  variant: z4.string().optional(),
+  peakRssBytes: z4.number().optional(),
+  peakProcCount: z4.number().optional(),
+  archived: z4.boolean(),
+  archivedAt: z4.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 and on any run not yet opened, both of which count as unread. */
+  seenAt: z4.string().optional(),
+  currentStepId: z4.string().optional(),
+  error: z4.string().optional(),
+  steps: z4.array(stepStateSchema),
+  /**
+   * The persisted workflow definition, so a `queued` run survives a restart — including the ad-hoc
+   * "(planned)" chains that exist nowhere else.
+   *
+   * The definition schema and NOT `z.record(z.string(), z.unknown())`: this key comes off the wire,
+   * so its values are whatever `JSON.parse` can produce and nothing else. `unknown` was wider than
+   * the server can serialize, and it made the route type unrepresentable here — hono maps `unknown`
+   * to its own `JSONValue`, whose index signature admits `object | symbol | undefined`. The fix was
+   * at the source: `src/runs/store.ts` persists a typed `workflowDefSchema` now, so the route's own
+   * type is this shape and the two-way check in `src/server/contract-parity.runs.test.ts` covers it
+   * like every other key.
+   */
+  workflowDef: workflowDefSchema.optional()
+});
+var apiRunSchema = runRecordSchema.extend({
+  usage: processUsageSchema.optional()
+});
+var createRunResponseSchema = z4.union([
+  runRecordSchema,
+  z4.object({ runs: z4.array(runRecordSchema) })
+]);
+var cancelResponseSchema = z4.object({ cancelled: z4.boolean() });
+var archiveFinishedResponseSchema = z4.object({ archived: z4.number() });
+var markAllReadResponseSchema = z4.object({ read: z4.number() });
+var deleteRunResponseSchema = z4.object({ deleted: z4.literal(true) });
+var finishResponseSchema = z4.object({ finished: z4.literal(true) });
+var continueResponseSchema = z4.object({ continued: z4.literal(true) });
+var createPrResponseSchema = z4.object({
+  url: z4.string(),
+  dryRun: z4.boolean()
+});
+var messageResponseSchema = z4.union([
+  z4.object({ delivered: z4.literal(true) }),
+  z4.object({ queued: z4.literal(true), message: queuedMessageSchema }),
+  z4.object({ deferred: z4.literal(true) })
+]);
+var editQueuedMessageResponseSchema = z4.object({ message: queuedMessageSchema });
+var removeQueuedMessageResponseSchema = z4.object({ removed: z4.literal(true) });
+var openInCliResponseSchema = z4.object({
+  opened: z4.literal(true),
+  command: z4.string()
+});
+var removeWorktreeResponseSchema = z4.object({ removed: z4.literal(true) });
+var gitCommitResponseSchema = z4.object({
+  committed: z4.literal(true),
+  sha: z4.string()
+});
+var gitPushResponseSchema = z4.object({
+  pushed: z4.literal(true),
+  branch: z4.string(),
+  remote: z4.string(),
+  upstreamSet: z4.boolean()
+});
+var runCommitSchema = z4.object({
+  sha: z4.string(),
+  subject: z4.string(),
+  author: z4.string(),
+  /** Relative time ("3 hours ago") — git's `%cr`. */
+  when: z4.string()
+});
+var runCommitsResponseSchema = z4.object({ commits: z4.array(runCommitSchema) });
+var groupVariantSchema = z4.object({
+  id: z4.string(),
+  /** 'A' | 'B' | 'C' in practice; `'?'` for a record that lost its letter. */
+  variant: z4.string(),
+  title: z4.string(),
+  status: runStatusSchema,
+  archived: z4.boolean(),
+  tokensUsed: z4.number(),
+  inputTokens: usageCounterSchema.optional(),
+  outputTokens: usageCounterSchema.optional(),
+  costUsd: z4.number().optional(),
+  diffStat: z4.string(),
+  /** First lines of the handoff journal's "## Progress log" section, as markdown. */
+  handoffExcerpt: z4.string()
+});
+var groupResponseSchema = z4.object({
+  groupId: z4.string(),
+  runs: z4.array(groupVariantSchema)
+});
+var pickVariantResponseSchema = z4.object({
+  winner: runRecordSchema.optional()
+});
+var imageInputSchema = z4.object({
+  mediaType: z4.string().regex(/^image\//),
+  data: z4.string().min(1).max(7e6)
+});
+var createRunInputBaseSchema = z4.object({
+  workflow: z4.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: z4.array(workflowStepDefSchema).min(1).max(8).optional(),
+  task: z4.string().min(1).max(1e5, "must be at most 100000 characters"),
+  model: z4.string().optional(),
+  runner: runnerSchema.optional(),
+  /** 1–3. Above 1 the response is `{ runs }` rather than a single record. */
+  variants: z4.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: z4.boolean().optional(),
+  /** true → autonomous run: never parks at "waiting"; auto-continues until done. */
+  autonomous: z4.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: z4.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: z4.string().trim().max(2e4, "must be at most 20000 characters").optional().transform((s) => s ? s : void 0),
+  /** Screenshots pasted into the new-task form; delivered with the first agent step. */
+  images: z4.array(imageInputSchema).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: z4.string().min(1).max(200, "must be at most 200 characters").optional()
+});
+var createRunInputSchema = createRunInputBaseSchema.refine(
+  (b) => Boolean(b.workflow) !== Boolean(b.steps),
+  { message: 'provide either "workflow" or "steps", not both' }
+);
+var messageInputSchema = z4.object({
+  text: z4.string().max(1e5).default(""),
+  images: z4.array(imageInputSchema).max(4).default([])
+}).refine((m) => m.text.trim().length > 0 || m.images.length > 0, {
+  message: "message needs text or at least one image"
+});
+var patchRunInputSchema = z4.object({
+  title: z4.string().trim().min(1).max(300).optional(),
+  task: z4.string().trim().min(1).max(1e5).optional()
+});
+
+// ../contract/src/repo.ts
+import { z as z5 } from "zod";
+var statusEntrySchema = z5.object({
+  status: z5.string(),
+  path: z5.string()
+});
+var logEntrySchema = z5.object({
+  hash: z5.string(),
+  subject: z5.string(),
+  author: z5.string(),
+  when: z5.string()
+});
+var repoResponseSchema = z5.union([
+  z5.object({
+    info: z5.null(),
+    status: z5.array(z5.never()),
+    log: z5.array(z5.never()),
+    branches: z5.array(z5.never()),
+    baseBranch: z5.null()
+  }),
+  z5.object({
+    info: repoInfoSchema,
+    status: z5.array(statusEntrySchema),
+    log: z5.array(logEntrySchema),
+    branches: z5.array(z5.string()),
+    baseBranch: z5.string().nullable()
+  })
+]);
+var repoBranchResponseSchema = z5.object({
+  branch: z5.string(),
+  created: z5.boolean()
+});
+var diffStatSchema2 = z5.object({
+  adds: z5.number(),
+  dels: z5.number(),
+  files: z5.number()
+});
+var changedFileSchema = z5.object({
+  path: z5.string(),
+  /** Rename/copy source — present only when `status` is renamed/copied. */
+  oldPath: z5.string().optional(),
+  status: z5.enum(["added", "modified", "deleted", "renamed", "copied"]),
+  adds: z5.number(),
+  dels: z5.number(),
+  /** Binary per numstat — there is no text patch to render. */
+  binary: z5.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: z5.boolean().optional(),
+  /** This file's unified-diff section; possibly `… (patch truncated)`, possibly empty. */
+  patch: z5.string()
+});
+var changesPayloadSchema = z5.object({
+  files: z5.array(changedFileSchema),
+  stat: diffStatSchema2,
+  /** Additive context for review tasks whose worktree HEAD no longer matches their own branch. */
+  repointedHead: z5.object({ headBranch: z5.string(), taskBranch: z5.string() }).optional()
+});
+var repoCommitPayloadSchema = z5.object({
+  sha: z5.string(),
+  subject: z5.string(),
+  author: z5.string(),
+  /** Relative time ("3 hours ago") — same `%cr` format as the /api/v1/repo log. */
+  when: z5.string(),
+  files: z5.array(changedFileSchema),
+  stat: diffStatSchema2
+});
+var worktreeDirEntrySchema = z5.object({
+  name: z5.string(),
+  type: z5.enum(["dir", "file"]),
+  size: z5.number().optional()
+});
+var worktreeEntrySchema = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal("dir"),
+    path: z5.string(),
+    entries: z5.array(worktreeDirEntrySchema)
+  }),
+  z5.object({
+    type: z5.literal("file"),
+    path: z5.string(),
+    size: z5.number(),
+    binary: z5.boolean(),
+    tooLarge: z5.boolean(),
+    content: z5.string().optional()
+  })
+]);
+var worktreeRunStatusSchema = z5.enum([
+  "queued",
+  "running",
+  "waiting",
+  "review",
+  "done",
+  "failed",
+  "cancelled"
+]);
+var worktreeInfoSchema = z5.object({
+  runId: z5.string(),
+  title: z5.string(),
+  status: worktreeRunStatusSchema,
+  branch: z5.string().nullable(),
+  sizeBytes: z5.number().nullable(),
+  finishedAt: z5.string().nullable(),
+  reclaimable: z5.boolean()
+});
+var worktreesResponseSchema = z5.object({
+  worktrees: z5.array(worktreeInfoSchema),
+  totalBytes: z5.number().nullable(),
+  keep: z5.number()
+});
+var reclaimWorktreesResponseSchema = z5.object({
+  reclaimed: z5.array(z5.string())
+});
+
+// ../contract/src/github.ts
+import { z as z6 } from "zod";
+var checksGlyphSchema = z6.enum(["passing", "failing", "pending"]).nullable();
+var githubItemSchema = z6.object({
+  kind: z6.enum(["issue", "pr"]),
+  number: z6.number(),
+  title: z6.string(),
+  author: z6.string(),
+  createdAt: z6.string(),
+  labels: z6.array(z6.string()),
+  body: z6.string(),
+  url: z6.string(),
+  comments: z6.number(),
+  /** PRs only. */
+  isDraft: z6.boolean().optional(),
+  additions: z6.number().optional(),
+  deletions: z6.number().optional(),
+  checks: checksGlyphSchema.optional()
+});
+var githubDataSchema = z6.object({
+  available: z6.boolean(),
+  /** Why it is unavailable (`gh` missing, no remote, offline…). Never an error — a hint. */
+  reason: z6.string().optional(),
+  /** owner/name, when known. */
+  repo: z6.string().optional(),
+  syncedAt: z6.string().optional(),
+  issues: z6.array(githubItemSchema),
+  prs: z6.array(githubItemSchema),
+  /** Repo-wide label name → 6-hex color (no `#`); lets chips tint like GitHub. Additive. */
+  labelColors: z6.record(z6.string(), z6.string()).optional()
+});
+var githubChecksDataSchema = z6.discriminatedUnion("available", [
+  z6.object({
+    available: z6.literal(true),
+    checks: z6.record(z6.number(), checksGlyphSchema)
+  }),
+  z6.object({
+    available: z6.literal(false),
+    reason: z6.string()
+  })
+]);
+var githubCommentSchema = z6.object({
+  id: z6.number(),
+  /** Author login, `'?'` fallback when gh omits the user. */
+  author: z6.string(),
+  avatarUrl: z6.string().optional(),
+  createdAt: z6.string(),
+  body: z6.string(),
+  kind: z6.enum(["comment", "review"]),
+  /** Reviews only — drives the state chip. */
+  reviewState: z6.enum(["approved", "changes_requested", "commented", "dismissed"]).optional(),
+  url: z6.string()
+});
+var githubTimelineEventKindSchema = z6.enum([
+  "committed",
+  "labeled",
+  "unlabeled",
+  "assigned",
+  "unassigned",
+  "merged",
+  "closed",
+  "reopened",
+  "head_ref_force_pushed",
+  "cross-referenced",
+  "renamed"
+]);
+var githubTimelineEventSchema = z6.object({
+  id: z6.string(),
+  kind: githubTimelineEventKindSchema,
+  /** Login — or the git author name for `committed`, which carries no GitHub actor. */
+  actor: z6.string(),
+  /** Absent for `committed`. */
+  avatarUrl: z6.string().optional(),
+  createdAt: z6.string(),
+  url: z6.string().optional(),
+  /** `committed` — full 40-char SHA. */
+  sha: z6.string().optional(),
+  /** `committed` — first line, capped at 120 chars. */
+  message: z6.string().optional(),
+  /** `committed` — **absent** (lookup failed/skipped) and **`null`** (no CI configured) both
+   *  render no glyph, but stay distinct values. */
+  checks: checksGlyphSchema.optional(),
+  label: z6.object({ name: z6.string(), color: z6.string().optional() }).optional(),
+  /** `assigned`/`unassigned` login, or the new title for `renamed`. */
+  subject: z6.string().optional(),
+  refNumber: z6.number().optional(),
+  refTitle: z6.string().optional(),
+  refIsPr: z6.boolean().optional()
+});
+var githubCommentsDataSchema = z6.object({
+  available: z6.boolean(),
+  reason: z6.string().optional(),
+  /** Chronological, oldest first. */
+  comments: z6.array(githubCommentSchema),
+  /** True when either stream hit its cap, or the timeline fetch stopped short. */
+  truncated: z6.boolean().optional(),
+  /** Timeline events (#525) — additive; absent when the server degraded to the legacy
+   *  comments-only fetch. Capped independently of `comments`. */
+  events: z6.array(githubTimelineEventSchema).optional()
+});
+var githubMergeMethodSchema = z6.enum(["merge", "squash", "rebase"]);
+var githubPrCheckSchema = z6.object({
+  name: z6.string(),
+  state: z6.enum(["passing", "failing", "pending", "unknown"]),
+  required: z6.boolean().nullable(),
+  url: z6.string().optional()
+});
+var githubPrMergeStateSchema = z6.object({
+  number: z6.number(),
+  title: z6.string(),
+  url: z6.string(),
+  state: z6.enum(["open", "closed", "merged"]),
+  isDraft: z6.boolean(),
+  headRef: z6.string(),
+  baseRef: z6.string(),
+  headSha: z6.string(),
+  mergeable: z6.enum(["mergeable", "conflicting", "unknown"]),
+  reviewDecision: z6.enum(["approved", "changes-requested", "review-required", "unknown"]),
+  checks: z6.array(githubPrCheckSchema),
+  methods: z6.array(githubMergeMethodSchema),
+  defaultMethod: githubMergeMethodSchema.nullable(),
+  eligibility: z6.enum(["ready", "blocked", "pending", "unauthorized", "terminal", "unknown"]),
+  blockers: z6.array(z6.object({ code: z6.string(), message: z6.string() })),
+  canMerge: z6.boolean(),
+  canOverride: z6.boolean()
+});
+var githubPrMergeStateResponseSchema = z6.discriminatedUnion("available", [
+  z6.object({ available: z6.literal(true), mergeState: githubPrMergeStateSchema }),
+  z6.object({ available: z6.literal(false), reason: z6.string() })
+]);
+var githubMergeResponseSchema = z6.object({
+  merged: z6.literal(true),
+  number: z6.number(),
+  url: z6.string(),
+  method: githubMergeMethodSchema,
+  mergeCommitSha: z6.string().optional()
+});
+var githubPrChangeSchema = z6.object({
+  path: z6.string(),
+  previousPath: z6.string().optional(),
+  status: z6.enum(["added", "modified", "removed", "renamed", "copied", "changed"]),
+  additions: z6.number(),
+  deletions: z6.number(),
+  patch: z6.string().optional(),
+  patchUnavailableReason: z6.enum(["binary", "too-large", "not-provided"]).optional(),
+  truncated: z6.boolean().optional()
+});
+var githubPrChangesDataSchema = z6.discriminatedUnion("available", [
+  z6.object({
+    available: z6.literal(true),
+    number: z6.number(),
+    headSha: z6.string(),
+    files: z6.array(githubPrChangeSchema),
+    additions: z6.number(),
+    deletions: z6.number(),
+    truncated: z6.boolean(),
+    /** Present when the payload is complete but partial in some other way (a capped patch). */
+    reason: z6.string().optional()
+  }),
+  z6.object({ available: z6.literal(false), reason: z6.string() })
+]);
+
+// ../contract/src/projects.ts
+import { z as z7 } from "zod";
+var projectListEntrySchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  /** Absolute, realpath-normalized repo root. */
+  root: z7.string(),
+  addedAt: z7.string(),
+  lastOpenedAt: z7.string(),
+  source: z7.enum(["local", "checkout"]),
+  /** `not-git` is fully usable (degraded single-queue mode); only `missing` blocks. */
+  status: z7.enum(["ok", "missing", "not-git"]),
+  /** Current branch when cheaply available (omitted e.g. on an unborn HEAD). */
+  branch: z7.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: z7.literal("github").optional(),
+  /** Per-project cap on concurrently running tasks (spec 2026-07-22). Omitted = inherit the
+   *  workspace `resources.maxParallel`; a number pins this project. */
+  maxParallel: z7.number().optional()
+});
+var projectsResponseSchema = z7.object({
+  projects: z7.array(projectListEntrySchema),
+  bootProject: z7.string(),
+  projectsDir: z7.string()
+});
+var registerProjectResponseSchema = z7.object({
+  project: projectListEntrySchema,
+  error: z7.string().optional()
+});
+var removeProjectResponseSchema = z7.object({
+  removed: z7.literal(true),
+  id: z7.string()
+});
+var updateProjectResponseSchema = z7.object({
+  project: projectListEntrySchema
+});
+var updateProjectInputSchema = z7.object({
+  maxParallel: z7.number().int().min(1).max(16).nullable()
+});
+var checkoutProjectInputSchema = z7.object({
+  url: z7.string().trim().min(1).max(512),
+  name: z7.string().trim().max(128).optional(),
+  checkoutId: z7.string().trim().max(128).optional()
+});
+var fsBrowseDirSchema = z7.object({
+  name: z7.string(),
+  path: z7.string(),
+  /** Has a `.git` entry — drives the "git" badge. A non-repo folder is still selectable. */
+  isRepo: z7.boolean()
+});
+var fsBrowseResponseSchema = z7.object({
+  /** The realpath'd directory actually listed — never the spelling asked for, so the breadcrumb
+   *  shows where the picker really is. */
+  path: z7.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: z7.string().nullable(),
+  dirs: z7.array(fsBrowseDirSchema),
+  /** True when the listing was capped server-side — surfaced honestly instead of showing a
+   *  silently short list. */
+  truncated: z7.boolean()
+});
+var launchKeyResponseSchema = z7.object({
+  key: z7.string()
+});
+
+// ../contract/src/workspace.ts
+import { z as z8 } from "zod";
+var workspaceConfigResponseSchema = z8.object({
+  /** Root exposed by the Add-project directory browser — stored as written (`~` kept). */
+  browseRoot: z8.string(),
+  /** Checkout root for GUI-cloned projects — stored as written (`~` kept). */
+  projectsDir: z8.string(),
+  /** Stored override; `null` means inherit `CEZ_SKILLS_AUTO_UPDATE`, then true. */
+  skillsAutoUpdate: z8.boolean().nullable(),
+  effectiveSkillsAutoUpdate: z8.boolean(),
+  composerDefaults: z8.object({
+    autonomous: z8.boolean().nullable(),
+    worktree: z8.boolean().nullable(),
+    /** `'source-dependent'` when no `CEZ_AUTONOMOUS_DEFAULT` pins it either way. */
+    inheritedAutonomous: z8.union([z8.boolean(), z8.literal("source-dependent")]),
+    inheritedWorktree: z8.boolean()
+  }),
+  resources: z8.object({
+    maxParallel: z8.number(),
+    maxMonitoringSessions: z8.number(),
+    monitoringWakeIntervalMinutes: z8.number().nullable(),
+    memoryLimitMb: z8.number().nullable(),
+    worktreeRetentionDefault: z8.number()
+  })
+});
+var setWorkspaceConfigInputSchema = z8.object({
+  browseRoot: z8.string().trim().min(1).max(4096).optional(),
+  projectsDir: z8.string().trim().min(1).max(4096).optional(),
+  skillsAutoUpdate: z8.boolean().nullable().optional(),
+  composerDefaults: z8.object({
+    autonomous: z8.boolean().nullable().optional(),
+    worktree: z8.boolean().nullable().optional()
+  }).optional(),
+  resources: z8.object({
+    maxParallel: z8.number().int().min(1).max(16).optional(),
+    maxMonitoringSessions: z8.number().int().min(0).max(16).optional(),
+    monitoringWakeIntervalMinutes: z8.number().int().min(1).max(60).nullable().optional(),
+    memoryLimitMb: z8.number().int().min(0).max(1048576).nullable().optional(),
+    worktreeRetentionDefault: z8.number().int().min(0).max(1e3).optional()
+  }).optional()
+});
+var appearanceSchema = z8.object({
+  accent: z8.enum(["lime", "violet"]).optional(),
+  density: z8.enum(["comfortable", "compact", "ultra"]).optional()
+});
+var uiStateSchema = z8.looseObject({
+  lastTask: z8.object({ source: z8.enum(["workflow", "skill"]), ref: z8.string() }).optional(),
+  /** Most-recently-run sources, newest first (deduped, capped). Feeds the composer picker's
+   *  recency sort. */
+  recentSources: z8.array(z8.object({ source: z8.enum(["workflow", "skill"]), ref: z8.string() })).optional(),
+  /** The last worktree choice for a single-skill run. Absent → the default (isolated worktree). */
+  lastWorktree: z8.boolean().optional(),
+  /** The last autonomous choice — remembered like `lastWorktree`. Absent → off. */
+  lastAutonomous: z8.boolean().optional(),
+  /** Whether new runs should ask agents to append follow-up work. Absent → on. */
+  lastGenerateFollowups: z8.boolean().optional(),
+  /** Skill selection frequency (#408): name → times chosen, across BOTH composers. */
+  skillUsage: z8.record(z8.string(), z8.number()).optional(),
+  runsView: z8.enum(["list", "table"]).optional(),
+  /** The GitHub tab's last-selected sub-tab (#417). Absent → issues. */
+  githubView: z8.enum(["issues", "prs"]).optional(),
+  /** Settings → Appearance. The theme itself stays in localStorage (`cez-theme`) — it must
+   *  pre-paint, and it is per-browser by design. */
+  appearance: appearanceSchema.optional(),
+  /** Follow-up prompt templates (#413). Absent → the built-in defaults; present (even `[]`) is
+   *  the user's own edited list. `skills` are the skill names the template auto-applies for. */
+  promptTemplates: z8.array(
+    z8.object({
+      id: z8.string(),
+      label: z8.string(),
+      text: z8.string(),
+      skills: z8.array(z8.string()).optional()
+    })
+  ).optional(),
+  /** The open-mercato/skills promo banner (#391), dismissed for good. Legacy — the banner is
+   *  gone, replaced by `WorkspaceUiState.importedSkills`; retained so old files round-trip. */
+  dismissedSkillsBanner: z8.boolean().optional()
+});
+var workspaceLastLocationSchema = z8.strictObject({
+  projectId: z8.string().min(1).max(64),
+  pathname: z8.string().min(1).max(2048).startsWith("/p/"),
+  search: z8.string().max(4096).startsWith("?").optional(),
+  hash: z8.string().max(2048).startsWith("#").optional()
+});
+var workspaceUiStateSchema = z8.looseObject({
+  /** The sidebar's per-project collapse map (step 3.3) — `true` collapses a group, `false` pins
+   *  it open, absent means the default (the active project expands, the rest collapse). Loose for
+   *  the same round-trip reason as its parent. */
+  sidebar: z8.looseObject({ collapsed: z8.record(z8.string(), z8.boolean()).optional() }).optional(),
+  /** Dismissed runtime-auth incident IDs, keyed by provider. An ID is only dismissed until the
+   *  provider reports a different incident, so this stays workspace-global with the browser
+   *  rather than one project checkout. */
+  dismissedProviderAuthFailures: z8.object({
+    claude: z8.string().optional(),
+    codex: z8.string().optional(),
+    opencode: z8.string().optional()
+  }).optional(),
+  /** Settings → Appearance, GLOBAL since step 3.5: accent + density describe the person at the
+   *  keyboard, not a repo. */
+  appearance: appearanceSchema.optional(),
+  /** Settings → Notifications, GLOBAL since step 3.5 — one answer for the whole workspace, since
+   *  the delivering browser is one browser whichever project you are looking at. */
+  notifications: z8.looseObject({ enabled: z8.boolean().optional() }).optional(),
+  /** Last settled project-scoped page. Used only when entering at the exact bare root;
+   *  explicit deep links always win. */
+  lastLocation: workspaceLastLocationSchema.optional(),
+  /** The user's curated selection of default (vendor) skills. Tri-state: ABSENT means "not
+   *  curated", so every default skill shows; a PRESENT array (even `[]`) means only those names
+   *  show from that repo. */
+  importedSkills: z8.array(z8.string()).optional()
+});
+var runnerModelsSchema = z8.object({
+  claude: z8.string().optional(),
+  codex: z8.string().optional(),
+  opencode: z8.string().optional()
+});
+var configResponseSchema = z8.object({
+  baseBranch: z8.string().nullable(),
+  defaultRunner: runnerSchema,
+  systemPrompt: z8.string().nullable(),
+  defaultModels: runnerModelsSchema,
+  /** How many tasks run at once (1–16). */
+  maxParallel: z8.number(),
+  /** Per-task memory ceiling in MiB (whole process tree); null = no limit. */
+  memoryLimitMb: z8.number().nullable(),
+  /** Keep the last N finished worktrees on disk (#483); 0 = unlimited. Older ones are reclaimed
+   *  (directory only — branch kept, so work is recoverable). */
+  worktreeRetention: z8.number(),
+  /** Live title updates: null = no config key, the `CEZ_TITLE_UPDATES` env default (ON) decides. */
+  liveTitleUpdates: z8.boolean().nullable(),
+  /** Optional review gate (#489): null = no config key, the `CEZ_REVIEW_GATE` env default (OFF)
+   *  decides. */
+  reviewGate: z8.boolean().nullable()
+});
+var setConfigResponseSchema = configResponseSchema;
+var setConfigInputSchema = z8.object({
+  baseBranch: z8.string().trim().min(1).max(200).nullable().optional(),
+  defaultRunner: runnerSchema.optional(),
+  systemPrompt: z8.string().trim().max(2e4).nullable().optional(),
+  defaultModels: z8.object({
+    claude: z8.string().trim().max(200).nullable().optional(),
+    codex: z8.string().trim().max(200).nullable().optional(),
+    opencode: z8.string().trim().max(200).nullable().optional()
+  }).optional(),
+  maxParallel: z8.number().int().min(1).max(16).optional(),
+  /** null or 0 clears the ceiling back to "no limit". */
+  memoryLimitMb: z8.number().int().min(0).max(1048576).nullable().optional(),
+  /** Keep last N finished worktrees (#483); 0 = unlimited, null clears back to the default (10). */
+  worktreeRetention: z8.number().int().min(0).max(1e3).nullable().optional(),
+  /** null clears the key back to the env-default behavior. */
+  liveTitleUpdates: z8.boolean().nullable().optional(),
+  /** null clears the key back to the env-default behavior (OFF). */
+  reviewGate: z8.boolean().nullable().optional()
+});
+var skillsUpdateStatusSchema = z8.enum([
+  "idle",
+  "checking",
+  "available",
+  "updating",
+  "current",
+  "unavailable",
+  "error"
+]);
+var skillsUpdateScopeStateSchema = z8.object({
+  scope: z8.enum(["project", "global"]),
+  status: skillsUpdateStatusSchema,
+  available: z8.boolean(),
+  skills: z8.array(z8.string()),
+  checkedAt: z8.string().nullable(),
+  updatedAt: z8.string().nullable(),
+  reason: z8.string().optional()
+});
+var skillsUpdateStateSchema = z8.object({
+  status: skillsUpdateStatusSchema,
+  available: z8.boolean(),
+  autoUpdateEnabled: z8.boolean(),
+  inherited: z8.boolean(),
+  checkedAt: z8.string().nullable(),
+  updatedAt: z8.string().nullable(),
+  scopes: z8.array(skillsUpdateScopeStateSchema),
+  needsUpgradeNotes: z8.boolean()
+});
+var providerIdSchema = runnerSchema;
+var providerConnectionStateSchema = z8.enum([
+  "connected",
+  "disconnected",
+  "not-installed",
+  "unknown"
+]);
+var providerStatusSchema = z8.object({
+  provider: providerIdSchema,
+  status: providerConnectionStateSchema,
+  enabled: z8.boolean().optional(),
+  hint: z8.string().optional(),
+  authFailureId: z8.string().optional()
+});
+var providerStatusResponseSchema = z8.object({
+  providers: z8.array(providerStatusSchema)
+});
+var providerConnectResponseSchema = z8.discriminatedUnion("opened", [
+  z8.object({ opened: z8.literal(true), command: z8.string() }),
+  z8.object({ opened: z8.literal(false), connected: z8.literal(true), command: z8.string() })
+]);
+var runnerModelOptionSchema = z8.object({
+  id: z8.string(),
+  label: z8.string(),
+  description: z8.string()
+});
+var runnerModelCatalogResponseSchema = z8.object({
+  runner: runnerSchema,
+  models: z8.array(runnerModelOptionSchema),
+  source: z8.enum(["live", "cache", "unavailable"]),
+  stale: z8.boolean(),
+  reason: z8.string().optional()
+});
+var openTargetSchema = z8.object({
+  id: z8.string(),
+  label: z8.string(),
+  /** A stable icon key (#361) the UI maps to a concrete icon. Optional: an older server omitting
+   *  it just renders the generic fallback icon. */
+  icon: z8.string().optional()
+});
+var openTargetsResponseSchema = z8.object({
+  targets: z8.array(openTargetSchema)
+});
+
+// ../contract/src/skills.ts
+import { z as z9 } from "zod";
+var skillSchema = z9.object({
+  name: z9.string(),
+  description: z9.string().optional(),
+  /** Advisory hint for untouched composer run-mode choices. */
+  interactive: z9.literal(true).optional(),
+  body: z9.string(),
+  path: z9.string(),
+  source: z9.enum(["ai", "cezar", "agents", "global", "team"]),
+  /** Team skills only: where the definition lives in its skills repo. */
+  team: z9.object({
+    repo: z9.string(),
+    ref: z9.string(),
+    path: z9.string(),
+    /** True for the `SKILL.md` convention — a whole directory (references/…). */
+    dir: z9.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: z9.string().optional()
+  }).optional()
+});
+var importableSkillSchema = z9.object({
+  name: z9.string(),
+  description: z9.string().optional()
+});
+var todoItemSchema = z9.object({
+  id: z9.string(),
+  ts: z9.string().optional(),
+  taskId: z9.string().optional(),
+  summary: z9.string().min(1),
+  action: z9.string().optional(),
+  prUrl: z9.string().optional(),
+  suggestedSkill: z9.string().optional(),
+  suggestedArgs: z9.string().optional(),
+  suggestedPrompt: z9.string().optional(),
+  /** Explicit intent; missing infers from suggestedSkill/suggestedPrompt for old files. */
+  runnable: z9.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: z9.string().optional()
+});
+var removeTodoResponseSchema = z9.object({
+  removed: z9.literal(true)
+});
+var startTodoResponseSchema = z9.object({
+  run: runRecordSchema
+});
+
+// ../contract/src/agent-config.ts
+import { z as z10 } from "zod";
+var agentConfigFormatSchema = z10.enum(["json", "jsonc", "toml", "markdown"]);
+var agentConfigScopeSchema = z10.enum(["user", "project", "local"]);
+var agentConfigKindSchema = z10.enum(["settings", "memory", "mcp"]);
+var agentConfigTrackedSchema = z10.enum(["tracked", "gitignored", "outside-repo"]);
+var agentConfigFileSchema = z10.object({
+  /** Stable, opaque, URL-safe — the ONLY thing a client may name (traversal-proof). */
+  id: z10.string(),
+  /** Every runner that reads this file: `<repo>/AGENTS.md` is one file, two readers. */
+  runners: z10.array(runnerSchema),
+  kind: agentConfigKindSchema,
+  scope: agentConfigScopeSchema,
+  label: z10.string(),
+  path: z10.string(),
+  format: agentConfigFormatSchema,
+  tracked: agentConfigTrackedSchema,
+  seeded: z10.boolean(),
+  holdsMcp: z10.boolean(),
+  /** VERBATIM from the vendor docs. Never computed, never generic. */
+  precedence: z10.string(),
+  /** Documented mid-run reload behaviour, or absent when the vendor is silent. */
+  hotReload: z10.string().optional(),
+  docsUrl: z10.string(),
+  exists: z10.boolean(),
+  size: z10.number(),
+  /** sha256 of the bytes, or null when absent. */
+  version: z10.string().nullable(),
+  /** False in hosted mode (whole feature) — the client renders read-only up front. */
+  writable: z10.boolean(),
+  readOnlyReason: z10.string().optional()
+});
+var userMcpListingSchema = z10.object({
+  path: z10.string(),
+  servers: z10.array(z10.string()),
+  readable: z10.boolean()
+});
+var agentConfigListingSchema = z10.object({
+  editable: z10.boolean(),
+  files: z10.array(agentConfigFileSchema),
+  /** null in hosted mode (host-state disclosure guard). */
+  userMcp: userMcpListingSchema.nullable()
+});
+var agentConfigFileContentSchema = z10.object({
+  id: z10.string(),
+  path: z10.string(),
+  exists: z10.boolean(),
+  content: z10.string(),
+  /** sha256 of the bytes, or null when the file does not exist yet. */
+  version: z10.string().nullable()
+});
+var setAgentConfigInputSchema = z10.object({
+  content: z10.string().max(2e6),
+  version: z10.string().nullable()
+});
+
+// ../contract/src/automations.ts
+import { z as z11 } from "zod";
+var automationEventSchema = z11.enum([
+  "pull_request.opened",
+  "issue.opened",
+  "issue.labeled",
+  "issue.unlabeled"
+]);
+var automationFiltersSchema = z11.object({
+  authors: z11.array(z11.string()).optional(),
+  assignees: z11.array(z11.string()).optional(),
+  allLabels: z11.array(z11.string()).optional(),
+  anyLabels: z11.array(z11.string()).optional(),
+  excludeLabels: z11.array(z11.string()).optional(),
+  /** Required for the two label events — the server rejects a definition without it. */
+  changedLabels: z11.array(z11.string()).optional(),
+  lookbackDays: z11.number(),
+  maxRecords: z11.number()
+});
+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: z11.string(),
+  variants: z11.union([z11.literal(1), z11.literal(2), z11.literal(3)]).optional(),
+  systemPrompt: z11.string().optional()
+});
+var automationDefinitionSchema = z11.object({
+  id: z11.string(),
+  /** Bumped on every edit; a PUT must echo the revision it read (optimistic concurrency). */
+  revision: z11.number(),
+  name: z11.string(),
+  description: z11.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: z11.boolean(),
+  events: z11.array(automationEventSchema),
+  intervalSeconds: z11.number(),
+  filters: automationFiltersSchema,
+  task: automationTaskSchema,
+  createdAt: z11.string(),
+  updatedAt: z11.string()
+});
+var automationCursorSchema = z11.object({
+  timestamp: z11.string(),
+  tieBreaker: z11.string().optional()
+});
+var automationRuntimeStateSchema = z11.object({
+  /** The definition revision this state belongs to; a bumped revision re-baselines. */
+  revision: z11.number().optional(),
+  /** Enabling establishes a CURRENT-TIME baseline: records older than this never launch. */
+  baselineAt: z11.string().optional(),
+  cursor: automationCursorSchema.optional(),
+  frozenHighWatermark: automationCursorSchema.extend({ tieBreaker: z11.string() }).optional(),
+  backlogAfter: automationCursorSchema.extend({ tieBreaker: z11.string() }).optional(),
+  nextCheckAt: z11.string().optional(),
+  lastSuccessAt: z11.string().optional(),
+  /** Per-query GitHub ETags, so an unchanged page costs no rate-limit budget. */
+  etags: z11.record(z11.string(), z11.string()).optional(),
+  backoffUntil: z11.string().optional(),
+  consecutiveFailures: z11.number().optional()
+});
+var automationLogResultSchema = z11.enum([
+  "launched",
+  "no-match",
+  "duplicate",
+  "rate-limited",
+  "error",
+  "baseline",
+  "preview"
+]);
+var automationLogRecordSchema = z11.object({
+  seq: z11.number(),
+  ts: z11.string(),
+  automationId: z11.string(),
+  revision: z11.number(),
+  event: automationEventSchema.optional(),
+  result: automationLogResultSchema,
+  reason: z11.string().optional(),
+  durationMs: z11.number().optional(),
+  receiptId: z11.string().optional(),
+  runId: z11.string().optional(),
+  githubNumber: z11.number().optional(),
+  githubTitle: z11.string().optional(),
+  githubUrl: z11.string().optional(),
+  rateLimit: z11.object({
+    bucket: z11.enum(["core", "search"]),
+    remaining: z11.number().optional(),
+    resetAt: z11.string().optional()
+  }).optional()
+});
+var automationCountsSchema = z11.object({
+  matches: z11.number(),
+  launched: z11.number(),
+  duplicates: z11.number(),
+  errors: z11.number()
+});
+var automationListEntrySchema = automationDefinitionSchema.extend({
+  state: automationRuntimeStateSchema.optional(),
+  latestLog: automationLogRecordSchema.optional(),
+  counts: automationCountsSchema
+});
+var automationsResponseSchema = z11.object({
+  available: z11.boolean(),
+  reason: z11.string().optional(),
+  scheduler: z11.object({
+    state: z11.enum(["scheduled", "idle"]),
+    nextDue: z11.string().optional()
+  }),
+  automations: z11.array(automationListEntrySchema)
+});
+var automationResponseSchema = z11.object({ automation: automationDefinitionSchema });
+var automationDetailResponseSchema = z11.object({
+  automation: automationDefinitionSchema,
+  state: automationRuntimeStateSchema.optional(),
+  latestLog: automationLogRecordSchema.optional()
+});
+var automationCheckSchema = z11.object({
+  id: z11.string(),
+  automationId: z11.string(),
+  mode: z11.enum(["preview", "execute"]),
+  status: z11.enum(["queued", "running", "complete", "error"]),
+  createdAt: z11.string(),
+  completedAt: z11.string().optional(),
+  matches: z11.number().optional(),
+  truncated: z11.boolean().optional(),
+  error: z11.string().optional()
+});
+var automationCheckQueuedResponseSchema = z11.object({ checkId: z11.string() });
+var automationLogResponseSchema = z11.object({
+  records: z11.array(automationLogRecordSchema)
+});
+var automationRetryResponseSchema = z11.object({
+  receiptId: z11.string(),
+  runId: z11.string()
+});
+var createAutomationInputSchema = automationDefinitionSchema.omit({ id: true, revision: true, createdAt: true, updatedAt: true, enabled: true }).extend({ enable: z11.boolean().optional() });
+var updateAutomationInputSchema = createAutomationInputSchema.omit({ enable: true }).extend({
+  enabled: z11.boolean().optional(),
+  expectedRevision: z11.number()
+});
+var automationCheckInputSchema = z11.object({
+  mode: z11.enum(["preview", "execute"])
+});
+export {
+  agentConfigFileContentSchema,
+  agentConfigFileSchema,
+  agentConfigFormatSchema,
+  agentConfigKindSchema,
+  agentConfigListingSchema,
+  agentConfigScopeSchema,
+  agentConfigTrackedSchema,
+  apiRunSchema,
+  archiveFinishedResponseSchema,
+  automationCheckInputSchema,
+  automationCheckQueuedResponseSchema,
+  automationCheckSchema,
+  automationCountsSchema,
+  automationCursorSchema,
+  automationDefinitionSchema,
+  automationDetailResponseSchema,
+  automationEventSchema,
+  automationFiltersSchema,
+  automationListEntrySchema,
+  automationLogRecordSchema,
+  automationLogResponseSchema,
+  automationLogResultSchema,
+  automationResponseSchema,
+  automationRetryResponseSchema,
+  automationRuntimeStateSchema,
+  automationTaskSchema,
+  automationsResponseSchema,
+  backendCheckSchema,
+  cancelResponseSchema,
+  capabilitiesSchema,
+  changedFileSchema,
+  changesPayloadSchema,
+  checkoutProgressEventSchema,
+  checkoutProjectInputSchema,
+  configResponseSchema,
+  continueResponseSchema,
+  createAutomationInputSchema,
+  createPrResponseSchema,
+  createRunInputBaseSchema,
+  createRunInputSchema,
+  createRunResponseSchema,
+  deleteRunResponseSchema,
+  deleteWorkflowResponseSchema,
+  diffStatSchema,
+  editQueuedMessageResponseSchema,
+  finishResponseSchema,
+  forgeInfoSchema,
+  fsBrowseDirSchema,
+  fsBrowseResponseSchema,
+  gitCommitResponseSchema,
+  gitPushResponseSchema,
+  githubChecksDataSchema,
+  githubCommentSchema,
+  githubCommentsDataSchema,
+  githubDataSchema,
+  githubItemSchema,
+  githubMergeMethodSchema,
+  githubMergeResponseSchema,
+  githubPrChangeSchema,
+  githubPrChangesDataSchema,
+  githubPrCheckSchema,
+  githubPrMergeStateResponseSchema,
+  githubPrMergeStateSchema,
+  githubTimelineEventKindSchema,
+  githubTimelineEventSchema,
+  groupResponseSchema,
+  groupVariantSchema,
+  healthResponseSchema,
+  imageInputSchema,
+  importableSkillSchema,
+  launchKeyResponseSchema,
+  logEntrySchema,
+  markAllReadResponseSchema,
+  messageInputSchema,
+  messageResponseSchema,
+  openInCliResponseSchema,
+  openTargetSchema,
+  openTargetsResponseSchema,
+  parsedWorkflowSchema,
+  patchRunInputSchema,
+  pickVariantResponseSchema,
+  planResponseSchema,
+  processUsageSchema,
+  projectListEntrySchema,
+  projectsResponseSchema,
+  providerConnectResponseSchema,
+  providerConnectionStateSchema,
+  providerIdSchema,
+  providerStatusResponseSchema,
+  providerStatusSchema,
+  queuedMessageSchema,
+  reclaimWorktreesResponseSchema,
+  registerProjectResponseSchema,
+  removeProjectResponseSchema,
+  removeQueuedMessageResponseSchema,
+  removeTodoResponseSchema,
+  removeWorktreeResponseSchema,
+  repoBranchResponseSchema,
+  repoCommitPayloadSchema,
+  repoInfoSchema,
+  repoResponseSchema,
+  runActivitySchema,
+  runCommitSchema,
+  runCommitsResponseSchema,
+  runEventSchema,
+  runRecordSchema,
+  runStatusSchema,
+  runnerModelCatalogResponseSchema,
+  runnerModelOptionSchema,
+  runnerModelsSchema,
+  runnerSchema,
+  saveWorkflowInputSchema,
+  saveWorkflowResponseSchema,
+  setAgentConfigInputSchema,
+  setConfigInputSchema,
+  setConfigResponseSchema,
+  setWorkspaceConfigInputSchema,
+  skillSchema,
+  skillsUpdateScopeStateSchema,
+  skillsUpdateStateSchema,
+  skillsUpdateStatusSchema,
+  startTodoResponseSchema,
+  statusEntrySchema,
+  stepStateSchema,
+  stepStatusSchema,
+  todoItemSchema,
+  uiStateSchema,
+  updateAutomationInputSchema,
+  updateProjectInputSchema,
+  updateProjectResponseSchema,
+  userMcpListingSchema,
+  workflowDefSchema,
+  workflowLoadIssueSchema,
+  workflowStepDefSchema,
+  workflowsResponseSchema,
+  workspaceConfigResponseSchema,
+  workspaceLastLocationSchema,
+  workspaceUiStateSchema,
+  worktreeDirEntrySchema,
+  worktreeEntrySchema,
+  worktreeInfoSchema,
+  worktreesResponseSchema
+};