@qodeca/xezar 0.13.1 → 0.14.0

package/dist/contract/index.js

@@ -118,64 +118,90 @@ var healthResponseSchema = z2.object({
   bootProject: z2.string()
 });
 
+// ../contract/src/mcp-ownership.ts
+import { z as z3 } from "zod";
+var MCP_PROJECT_OCCUPIED_CODE = -32080;
+var MCP_SESSION_EXPIRED_CODE = -32081;
+var MCP_PROJECT_OCCUPIED_REASON = "com.qodeca.xezar/project-occupied";
+var MCP_SESSION_EXPIRED_REASON = "com.qodeca.xezar/session-expired";
+var mcpProjectOccupiedErrorSchema = z3.object({
+  code: z3.literal(MCP_PROJECT_OCCUPIED_CODE),
+  message: z3.string().min(1),
+  data: z3.object({
+    reason: z3.literal(MCP_PROJECT_OCCUPIED_REASON),
+    projectId: z3.string().min(1),
+    retryable: z3.literal(true)
+  }).strict()
+}).strict();
+var mcpSessionExpiredErrorSchema = z3.object({
+  code: z3.literal(MCP_SESSION_EXPIRED_CODE),
+  message: z3.string().min(1),
+  data: z3.object({
+    reason: z3.literal(MCP_SESSION_EXPIRED_REASON),
+    projectId: z3.string().min(1),
+    retryable: z3.literal(true)
+  }).strict()
+}).strict();
+var projectOwnerStateSchema = z3.enum(["unowned", "owned", "expired"]);
+
 // ../contract/src/runs.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // ../contract/src/github.ts
-import { z as z3 } from "zod";
-var checksGlyphSchema = z3.enum(["passing", "failing", "pending"]).nullable();
-var githubItemSchema = z3.object({
-  kind: z3.enum(["issue", "pr"]),
-  number: z3.number(),
-  title: z3.string(),
-  author: z3.string(),
-  createdAt: z3.string(),
-  labels: z3.array(z3.string()),
-  body: z3.string(),
-  url: z3.string(),
-  comments: z3.number(),
+import { z as z4 } from "zod";
+var checksGlyphSchema = z4.enum(["passing", "failing", "pending"]).nullable();
+var githubItemSchema = z4.object({
+  kind: z4.enum(["issue", "pr"]),
+  number: z4.number(),
+  title: z4.string(),
+  author: z4.string(),
+  createdAt: z4.string(),
+  labels: z4.array(z4.string()),
+  body: z4.string(),
+  url: z4.string(),
+  comments: z4.number(),
   /** PRs only. */
-  isDraft: z3.boolean().optional(),
-  additions: z3.number().optional(),
-  deletions: z3.number().optional(),
+  isDraft: z4.boolean().optional(),
+  additions: z4.number().optional(),
+  deletions: z4.number().optional(),
   checks: checksGlyphSchema.optional()
 });
-var githubDataSchema = z3.object({
-  available: z3.boolean(),
+var githubDataSchema = z4.object({
+  available: z4.boolean(),
   /** Why it is unavailable (`gh` missing, no remote, offline…). Never an error — a hint. */
-  reason: z3.string().optional(),
+  reason: z4.string().optional(),
   /** owner/name, when known. */
-  repo: z3.string().optional(),
-  syncedAt: z3.string().optional(),
-  issues: z3.array(githubItemSchema),
-  prs: z3.array(githubItemSchema),
+  repo: z4.string().optional(),
+  syncedAt: z4.string().optional(),
+  issues: z4.array(githubItemSchema),
+  prs: z4.array(githubItemSchema),
   /** Repo-wide label name → 6-hex color (no `#`); lets chips tint like GitHub. Additive. */
-  labelColors: z3.record(z3.string(), z3.string()).optional()
+  labelColors: z4.record(z4.string(), z4.string()).optional()
 });
-var githubChecksDataSchema = z3.discriminatedUnion("available", [
-  z3.object({
-    available: z3.literal(true),
-    checks: z3.record(z3.number(), checksGlyphSchema)
+var githubChecksDataSchema = z4.discriminatedUnion("available", [
+  z4.object({
+    available: z4.literal(true),
+    checks: z4.record(z4.number(), checksGlyphSchema)
   }),
-  z3.object({
-    available: z3.literal(false),
-    reason: z3.string()
+  z4.object({
+    available: z4.literal(false),
+    reason: z4.string()
   })
 ]);
-var githubSearchDataSchema = z3.object({
-  available: z3.boolean(),
+var githubSearchDataSchema = z4.object({
+  available: z4.boolean(),
   /** Why it could not search (`gh` missing, no remote, rate-limited…). A hint, never an error. */
-  reason: z3.string().optional(),
+  reason: z4.string().optional(),
   /** The same rows the list ships. `checks` is always `null` here — hydrated lazily through
    *  `/github/checks`, exactly as list rows have been since #664. */
-  items: z3.array(githubItemSchema),
+  items: z4.array(githubItemSchema),
   /** The hit list filled the server's cap; there may be more matches on the forge. */
-  truncated: z3.boolean().optional(),
+  truncated: z4.boolean().optional(),
   /** Label name → 6-hex color for the labels these hits carry. A closed item often wears labels
    *  no open one does, which the repo-wide map from the list call would not cover. Additive. */
-  labelColors: z3.record(z3.string(), z3.string()).optional()
+  labelColors: z4.record(z4.string(), z4.string()).optional()
 });
-var referenceStatusSchema = z3.enum([
+var referenceStatusSchema = z4.enum([
   "draft",
   "review-required",
   "changes-requested",
@@ -188,13 +214,13 @@ var referenceStatusSchema = z3.enum([
   "completed",
   "not-planned"
 ]);
-var recheckAfterMsSchema = z3.number().nullable();
+var recheckAfterMsSchema = z4.number().nullable();
 var REFERENCE_STATUS_MAX = 100;
-var githubRefStatusDataSchema = z3.discriminatedUnion("available", [
-  z3.object({
-    available: z3.literal(true),
-    prs: z3.record(z3.number(), referenceStatusSchema),
-    issues: z3.record(z3.number(), referenceStatusSchema),
+var githubRefStatusDataSchema = z4.discriminatedUnion("available", [
+  z4.object({
+    available: z4.literal(true),
+    prs: z4.record(z4.number(), referenceStatusSchema),
+    issues: z4.record(z4.number(), referenceStatusSchema),
     /**
      * The pull request numbers that do NOT merge cleanly into their base right now.
      *
@@ -214,28 +240,28 @@ var githubRefStatusDataSchema = z3.discriminatedUnion("available", [
      * ever named — GitHub reports `UNKNOWN` for merged and closed ones, and `UNKNOWN` (which is
      * also what it answers while it is still computing) is never listed.
      */
-    conflicts: z3.array(z3.number()).optional(),
+    conflicts: z4.array(z4.number()).optional(),
     recheckAfterMs: recheckAfterMsSchema
   }),
-  z3.object({
-    available: z3.literal(false),
-    reason: z3.string(),
+  z4.object({
+    available: z4.literal(false),
+    reason: z4.string(),
     recheckAfterMs: recheckAfterMsSchema
   })
 ]);
-var githubCommentSchema = z3.object({
-  id: z3.number(),
+var githubCommentSchema = z4.object({
+  id: z4.number(),
   /** Author login, `'?'` fallback when gh omits the user. */
-  author: z3.string(),
-  avatarUrl: z3.string().optional(),
-  createdAt: z3.string(),
-  body: z3.string(),
-  kind: z3.enum(["comment", "review"]),
+  author: z4.string(),
+  avatarUrl: z4.string().optional(),
+  createdAt: z4.string(),
+  body: z4.string(),
+  kind: z4.enum(["comment", "review"]),
   /** Reviews only — drives the state chip. */
-  reviewState: z3.enum(["approved", "changes_requested", "commented", "dismissed"]).optional(),
-  url: z3.string()
+  reviewState: z4.enum(["approved", "changes_requested", "commented", "dismissed"]).optional(),
+  url: z4.string()
 });
-var githubTimelineEventKindSchema = z3.enum([
+var githubTimelineEventKindSchema = z4.enum([
   "committed",
   "labeled",
   "unlabeled",
@@ -248,178 +274,223 @@ var githubTimelineEventKindSchema = z3.enum([
   "cross-referenced",
   "renamed"
 ]);
-var githubTimelineEventSchema = z3.object({
-  id: z3.string(),
+var githubTimelineEventSchema = z4.object({
+  id: z4.string(),
   kind: githubTimelineEventKindSchema,
   /** Login — or the git author name for `committed`, which carries no GitHub actor. */
-  actor: z3.string(),
+  actor: z4.string(),
   /** Absent for `committed`. */
-  avatarUrl: z3.string().optional(),
-  createdAt: z3.string(),
-  url: z3.string().optional(),
+  avatarUrl: z4.string().optional(),
+  createdAt: z4.string(),
+  url: z4.string().optional(),
   /** `committed` — full 40-char SHA. */
-  sha: z3.string().optional(),
+  sha: z4.string().optional(),
   /** `committed` — first line, capped at 120 chars. */
-  message: z3.string().optional(),
+  message: z4.string().optional(),
   /** `committed` — **absent** (lookup failed/skipped) and **`null`** (no CI configured) both
    *  render no glyph, but stay distinct values. */
   checks: checksGlyphSchema.optional(),
-  label: z3.object({ name: z3.string(), color: z3.string().optional() }).optional(),
+  label: z4.object({ name: z4.string(), color: z4.string().optional() }).optional(),
   /** `assigned`/`unassigned` login, or the new title for `renamed`. */
-  subject: z3.string().optional(),
-  refNumber: z3.number().optional(),
-  refTitle: z3.string().optional(),
-  refIsPr: z3.boolean().optional()
-});
-var githubCommentsDataSchema = z3.object({
-  available: z3.boolean(),
-  reason: z3.string().optional(),
+  subject: z4.string().optional(),
+  refNumber: z4.number().optional(),
+  refTitle: z4.string().optional(),
+  refIsPr: z4.boolean().optional()
+});
+var githubCommentsDataSchema = z4.object({
+  available: z4.boolean(),
+  reason: z4.string().optional(),
   /** Chronological, oldest first. */
-  comments: z3.array(githubCommentSchema),
+  comments: z4.array(githubCommentSchema),
   /** True when either stream hit its cap, or the timeline fetch stopped short. */
-  truncated: z3.boolean().optional(),
+  truncated: z4.boolean().optional(),
   /** Timeline events (#525) — additive; absent when the server degraded to the legacy
    *  comments-only fetch. Capped independently of `comments`. */
-  events: z3.array(githubTimelineEventSchema).optional()
-});
-var githubMergeMethodSchema = z3.enum(["merge", "squash", "rebase"]);
-var githubPrCheckSchema = z3.object({
-  name: z3.string(),
-  state: z3.enum(["passing", "failing", "pending", "unknown"]),
-  required: z3.boolean().nullable(),
-  url: z3.string().optional()
-});
-var githubPrMergeStateSchema = z3.object({
-  number: z3.number(),
-  title: z3.string(),
-  url: z3.string(),
-  state: z3.enum(["open", "closed", "merged"]),
-  isDraft: z3.boolean(),
-  headRef: z3.string(),
-  baseRef: z3.string(),
-  headSha: z3.string(),
-  mergeable: z3.enum(["mergeable", "conflicting", "unknown"]),
-  reviewDecision: z3.enum(["approved", "changes-requested", "review-required", "unknown"]),
-  checks: z3.array(githubPrCheckSchema),
-  methods: z3.array(githubMergeMethodSchema),
+  events: z4.array(githubTimelineEventSchema).optional()
+});
+var githubMergeMethodSchema = z4.enum(["merge", "squash", "rebase"]);
+var githubPrCheckSchema = z4.object({
+  name: z4.string(),
+  state: z4.enum(["passing", "failing", "pending", "unknown"]),
+  required: z4.boolean().nullable(),
+  url: z4.string().optional()
+});
+var githubPrMergeStateSchema = z4.object({
+  number: z4.number(),
+  title: z4.string(),
+  url: z4.string(),
+  state: z4.enum(["open", "closed", "merged"]),
+  isDraft: z4.boolean(),
+  headRef: z4.string(),
+  baseRef: z4.string(),
+  headSha: z4.string(),
+  mergeable: z4.enum(["mergeable", "conflicting", "unknown"]),
+  reviewDecision: z4.enum(["approved", "changes-requested", "review-required", "unknown"]),
+  checks: z4.array(githubPrCheckSchema),
+  methods: z4.array(githubMergeMethodSchema),
   defaultMethod: githubMergeMethodSchema.nullable(),
-  eligibility: z3.enum(["ready", "blocked", "pending", "unauthorized", "terminal", "unknown"]),
-  blockers: z3.array(z3.object({ code: z3.string(), message: z3.string() })),
-  canMerge: z3.boolean(),
-  canOverride: z3.boolean()
-});
-var githubPrMergeStateResponseSchema = z3.discriminatedUnion("available", [
-  z3.object({ available: z3.literal(true), mergeState: githubPrMergeStateSchema }),
-  z3.object({ available: z3.literal(false), reason: z3.string() })
+  eligibility: z4.enum(["ready", "blocked", "pending", "unauthorized", "terminal", "unknown"]),
+  blockers: z4.array(z4.object({ code: z4.string(), message: z4.string() })),
+  canMerge: z4.boolean(),
+  canOverride: z4.boolean()
+});
+var githubPrMergeStateResponseSchema = z4.discriminatedUnion("available", [
+  z4.object({ available: z4.literal(true), mergeState: githubPrMergeStateSchema }),
+  z4.object({ available: z4.literal(false), reason: z4.string() })
 ]);
-var githubMergeResponseSchema = z3.object({
-  merged: z3.literal(true),
-  number: z3.number(),
-  url: z3.string(),
+var githubMergeResponseSchema = z4.object({
+  merged: z4.literal(true),
+  number: z4.number(),
+  url: z4.string(),
   method: githubMergeMethodSchema,
-  mergeCommitSha: z3.string().optional()
-});
-var githubPrChangeSchema = z3.object({
-  path: z3.string(),
-  previousPath: z3.string().optional(),
-  status: z3.enum(["added", "modified", "removed", "renamed", "copied", "changed"]),
-  additions: z3.number(),
-  deletions: z3.number(),
-  patch: z3.string().optional(),
-  patchUnavailableReason: z3.enum(["binary", "too-large", "not-provided"]).optional(),
-  truncated: z3.boolean().optional()
-});
-var githubPrChangesDataSchema = z3.discriminatedUnion("available", [
-  z3.object({
-    available: z3.literal(true),
-    number: z3.number(),
-    headSha: z3.string(),
-    files: z3.array(githubPrChangeSchema),
-    additions: z3.number(),
-    deletions: z3.number(),
-    truncated: z3.boolean(),
+  mergeCommitSha: z4.string().optional()
+});
+var githubPrReadyInputSchema = z4.object({ expectedHeadSha: z4.string().regex(/^[0-9a-f]{40}$/) }).strict();
+var githubPrReadyResponseSchema = z4.object({
+  ready: z4.literal(true),
+  number: z4.number(),
+  url: z4.string()
+});
+var githubPrChangeSchema = z4.object({
+  path: z4.string(),
+  previousPath: z4.string().optional(),
+  status: z4.enum(["added", "modified", "removed", "renamed", "copied", "changed"]),
+  additions: z4.number(),
+  deletions: z4.number(),
+  patch: z4.string().optional(),
+  patchUnavailableReason: z4.enum(["binary", "too-large", "not-provided"]).optional(),
+  truncated: z4.boolean().optional()
+});
+var githubPrChangesDataSchema = z4.discriminatedUnion("available", [
+  z4.object({
+    available: z4.literal(true),
+    number: z4.number(),
+    headSha: z4.string(),
+    files: z4.array(githubPrChangeSchema),
+    additions: z4.number(),
+    deletions: z4.number(),
+    truncated: z4.boolean(),
     /** Present when the payload is complete but partial in some other way (a capped patch). */
-    reason: z3.string().optional()
+    reason: z4.string().optional()
   }),
-  z3.object({ available: z3.literal(false), reason: z3.string() })
+  z4.object({ available: z4.literal(false), reason: z4.string() })
+]);
+
+// ../contract/src/mcp-versioning.ts
+import { z as z5 } from "zod";
+var MCP_VERSION_TOKEN_TAG = "rev1";
+var mcpVersionTokenSchema = z5.string().min(1).max(512);
+var mcpExpectedVersionSchema = mcpVersionTokenSchema;
+var mcpVersionedResourceKindSchema = z5.string().min(1).max(32).regex(/^[a-z][a-z0-9-]*$/);
+var mcpVersionedResourceRefSchema = z5.object({
+  kind: mcpVersionedResourceKindSchema,
+  id: z5.string().min(1)
+});
+var MCP_STALE_VERSION_GUIDANCE = "Not applied: this changed after you read it. Read the current state and decide again; a new decision is a new operation.";
+var MCP_EXECUTION_FAILED_GUIDANCE = "Attempted and failed: the change ran and did not complete, so part of it may have applied. Read the current state before deciding again; do not repeat it blindly.";
+var staleVersionRejectionSchema = z5.object({
+  status: z5.literal("conflict"),
+  applied: z5.literal(false),
+  error: z5.literal("stale_version"),
+  resource: mcpVersionedResourceRefSchema,
+  currentVersion: mcpVersionTokenSchema.optional(),
+  changedSince: z5.literal(true),
+  guidance: z5.literal(MCP_STALE_VERSION_GUIDANCE)
+});
+var executionFailedSchema = z5.object({
+  status: z5.literal("failed"),
+  executed: z5.literal(true),
+  error: z5.literal("execution_failed"),
+  resource: mcpVersionedResourceRefSchema,
+  guidance: z5.literal(MCP_EXECUTION_FAILED_GUIDANCE)
+});
+var versionedMutationDoneSchema = z5.object({
+  status: z5.literal("done"),
+  resource: mcpVersionedResourceRefSchema,
+  version: mcpVersionTokenSchema.optional()
+});
+var versionedMutationOutcomeSchema = z5.discriminatedUnion("status", [
+  versionedMutationDoneSchema,
+  staleVersionRejectionSchema,
+  executionFailedSchema
 ]);
 
 // ../contract/src/workflows.ts
-import { z as z4 } from "zod";
-var workflowStepDefSchema = z4.object({
-  id: z4.string().min(1),
-  name: z4.string().optional(),
+import { z as z6 } from "zod";
+var workflowStepDefSchema = z6.object({
+  id: z6.string().min(1),
+  name: z6.string().optional(),
   // agent step
-  prompt: z4.string().optional(),
-  skill: z4.string().optional(),
-  model: z4.string().optional(),
+  prompt: z6.string().optional(),
+  skill: z6.string().optional(),
+  model: z6.string().optional(),
   /** Per-step agent backend override (falls back to the task / config default). */
   runner: runnerSchema.optional(),
-  allowedTools: z4.array(z4.string()).optional(),
-  bashAllowlist: z4.array(z4.string()).optional(),
+  allowedTools: z6.array(z6.string()).optional(),
+  bashAllowlist: z6.array(z6.string()).optional(),
   /** This step's own wall-clock cap (#22): `45s` / `90m` / `2h`, or `none` for no cap.
    *  Typed as a plain string here, exactly as `model` is: the DURATION FORMAT is validated
    *  by `src/workflows/types.ts`'s `stepTimeoutSchema`, which is the single source of truth
    *  for what a user may author (workflow YAML and the inline chain on `POST /runs` both go
    *  through it). Restating the grammar here would be a second copy free to drift. */
-  timeout: z4.string().optional(),
+  timeout: z6.string().optional(),
   // check step
-  command: z4.string().optional(),
-  onFail: z4.object({
-    retry: z4.string().min(1),
-    max: z4.number().int().positive().default(2)
+  command: z6.string().optional(),
+  onFail: z6.object({
+    retry: z6.string().min(1),
+    max: z6.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 = z4.object({
-  name: z4.string(),
-  description: z4.string().optional(),
-  steps: z4.array(workflowStepDefSchema),
-  source: z4.enum(["built-in", "file"]),
+var workflowDefSchema = z6.object({
+  name: z6.string(),
+  description: z6.string().optional(),
+  steps: z6.array(workflowStepDefSchema),
+  source: z6.enum(["built-in", "file"]),
   /** Absent on built-ins — which is exactly what makes them undeletable. */
-  path: z4.string().optional()
+  path: z6.string().optional()
 });
-var workflowLoadIssueSchema = z4.object({
-  path: z4.string(),
-  message: z4.string()
-});
-var workflowsResponseSchema = z4.object({
-  workflows: z4.array(workflowDefSchema),
-  issues: z4.array(workflowLoadIssueSchema)
-});
-var saveWorkflowInputSchema = z4.object({
-  name: z4.string().trim().min(1).max(80),
-  description: z4.string().max(2e3, "must be at most 2000 characters").optional(),
-  steps: z4.array(workflowStepDefSchema).min(1).max(8).optional(),
-  skills: z4.array(z4.string().trim().min(1)).min(1).max(8).optional(),
-  overwrite: z4.boolean().optional()
+var workflowLoadIssueSchema = z6.object({
+  path: z6.string(),
+  message: z6.string()
+});
+var workflowsResponseSchema = z6.object({
+  workflows: z6.array(workflowDefSchema),
+  issues: z6.array(workflowLoadIssueSchema)
+});
+var saveWorkflowInputSchema = z6.object({
+  name: z6.string().trim().min(1).max(80),
+  description: z6.string().max(2e3, "must be at most 2000 characters").optional(),
+  steps: z6.array(workflowStepDefSchema).min(1).max(8).optional(),
+  skills: z6.array(z6.string().trim().min(1)).min(1).max(8).optional(),
+  overwrite: z6.boolean().optional()
 }).refine((b) => Boolean(b.steps) !== Boolean(b.skills), {
   message: 'provide either "steps" or "skills", not both'
 });
-var saveWorkflowResponseSchema = z4.object({
-  path: z4.string(),
-  name: z4.string()
+var saveWorkflowResponseSchema = z6.object({
+  path: z6.string(),
+  name: z6.string()
 });
-var parsedWorkflowSchema = z4.object({
-  name: z4.string(),
-  description: z4.string().optional(),
-  steps: z4.array(workflowStepDefSchema)
+var parsedWorkflowSchema = z6.object({
+  name: z6.string(),
+  description: z6.string().optional(),
+  steps: z6.array(workflowStepDefSchema)
 });
-var deleteWorkflowResponseSchema = z4.object({
-  ok: z4.literal(true),
-  path: z4.string()
+var deleteWorkflowResponseSchema = z6.object({
+  ok: z6.literal(true),
+  path: z6.string()
 });
-var planResponseSchema = z4.object({
+var planResponseSchema = z6.object({
   /** The kebab-case workflow title the planner proposed. Absent on the degraded fallback. */
-  name: z4.string().optional(),
-  steps: z4.array(workflowStepDefSchema),
-  rationale: z4.string(),
-  fallback: z4.boolean()
+  name: z6.string().optional(),
+  steps: z6.array(workflowStepDefSchema),
+  rationale: z6.string(),
+  fallback: z6.boolean()
 });
 
 // ../contract/src/runs.ts
-var runStatusSchema = z5.enum([
+var runStatusSchema = z7.enum([
   "queued",
   "running",
   "waiting",
@@ -428,8 +499,8 @@ var runStatusSchema = z5.enum([
   "failed",
   "cancelled"
 ]);
-var runActivitySchema = z5.enum(["monitoring"]);
-var stepStatusSchema = z5.enum([
+var runActivitySchema = z7.enum(["monitoring"]);
+var stepStatusSchema = z7.enum([
   "pending",
   "running",
   "waiting",
@@ -439,14 +510,14 @@ var stepStatusSchema = z5.enum([
   "cancelled",
   "skipped"
 ]);
-var usageCounterSchema = z5.number().finite().nonnegative();
-var stepStateSchema = z5.object({
-  id: z5.string(),
-  name: z5.string(),
-  kind: z5.enum(["agent", "check"]),
+var usageCounterSchema = z7.number().finite().nonnegative();
+var stepStateSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  kind: z7.enum(["agent", "check"]),
   status: stepStatusSchema,
-  iterations: z5.number(),
-  tokensUsed: z5.number(),
+  iterations: z7.number(),
+  tokensUsed: z7.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
   usageInvocationsStarted: usageCounterSchema.optional(),
@@ -454,76 +525,76 @@ var stepStateSchema = z5.object({
   usageTurnsStarted: usageCounterSchema.optional(),
   usageTurnsRecorded: usageCounterSchema.optional(),
   usageInvocationEpoch: usageCounterSchema.optional(),
-  startedAt: z5.string().optional(),
-  finishedAt: z5.string().optional(),
-  error: z5.string().optional(),
+  startedAt: z7.string().optional(),
+  finishedAt: z7.string().optional(),
+  error: z7.string().optional(),
   /** Latest agent session id — `claude --resume <id>` and friends. */
-  sessionId: z5.string().optional(),
+  sessionId: z7.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: z5.string().optional(),
-  costUsd: z5.number().optional()
+  profileId: z7.string().optional(),
+  costUsd: z7.number().optional()
 });
-var diffStatSchema = z5.object({
-  adds: z5.number(),
-  dels: z5.number(),
-  files: z5.number(),
+var diffStatSchema = z7.object({
+  adds: z7.number(),
+  dels: z7.number(),
+  files: z7.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: z5.boolean().optional()
+  repointed: z7.boolean().optional()
 });
-var queuedMessageSchema = z5.object({
-  id: z5.string(),
-  text: z5.string(),
+var queuedMessageSchema = z7.object({
+  id: z7.string(),
+  text: z7.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: z5.array(z5.string()).optional(),
-  createdAt: z5.string()
+  images: z7.array(z7.string()).optional(),
+  createdAt: z7.string()
 });
-var processUsageSchema = z5.object({
+var processUsageSchema = z7.object({
   /** Sum of `%cpu` across the tree — can exceed 100 on multi-core work. */
-  cpuPct: z5.number(),
-  rssBytes: z5.number(),
-  procCount: z5.number()
+  cpuPct: z7.number(),
+  rssBytes: z7.number(),
+  procCount: z7.number()
 });
-var runRecordSchema = z5.object({
-  id: z5.string(),
-  title: z5.string(),
+var runRecordSchema = z7.object({
+  id: z7.string(),
+  title: z7.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: z5.string().optional(),
+  titleSummary: z7.string().optional(),
   /** Refreshed on every turn-end; absent until the first turn ends (and on worktree-less runs). */
   diffStat: diffStatSchema.optional(),
-  workflow: z5.string(),
-  task: z5.string(),
+  workflow: z7.string(),
+  task: z7.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: z5.array(queuedMessageSchema).optional(),
+  queuedMessages: z7.array(queuedMessageSchema).optional(),
   /** URLs of the attachments on the initial task prompt (#image-display) — images and, since
    *  #950, files. One list, one numbering space; branch on `isImageAttachmentName`. */
-  taskImages: z5.array(z5.string()).optional(),
-  model: z5.string().optional(),
+  taskImages: z7.array(z7.string()).optional(),
+  model: z7.string().optional(),
   /** Normalized provider/model identity used for attribution and reproducible replay. */
-  modelIdentity: z5.string().optional(),
+  modelIdentity: z7.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: z5.string().optional(),
+  agentProfile: z7.string().optional(),
   /** Echo of the extra system prompt the run used (POST override or config default). */
-  systemPrompt: z5.string().optional(),
+  systemPrompt: z7.string().optional(),
   /** false when the run deliberately disabled follow-up todo generation. Absent means enabled. */
-  generateFollowups: z5.boolean().optional(),
+  generateFollowups: z7.boolean().optional(),
   /** Autonomous mode (#autonomous): the run never parks at `waiting` or the terminal `review`
    *  gate. Absent = falsy = not autonomous. */
-  autonomous: z5.boolean().optional(),
+  autonomous: z7.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
@@ -533,94 +604,94 @@ var runRecordSchema = z5.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 xezar can still read a record written by a newer one.
    */
-  automation: z5.object({
-    automationId: z5.string(),
-    automationRevision: z5.number(),
-    receiptId: z5.string(),
-    event: z5.string(),
-    githubUrl: z5.string()
+  automation: z7.object({
+    automationId: z7.string(),
+    automationRevision: z7.number(),
+    receiptId: z7.string(),
+    event: z7.string(),
+    githubUrl: z7.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: z5.string().optional(),
+  monitoringWakeAt: z7.string().optional(),
   /** The current live monitoring epoch exhausted its 40 automatic checks. */
-  monitoringWakeCapReached: z5.boolean().optional(),
+  monitoringWakeCapReached: z7.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: z5.string().optional(),
+  autoResumeAt: z7.string().optional(),
   /** Consecutive automatic resumes since the last human turn, against the safety cap. */
-  autoResumeAttempts: z5.number().optional(),
-  createdAt: z5.string(),
-  startedAt: z5.string().optional(),
-  finishedAt: z5.string().optional(),
-  tokensUsed: z5.number(),
+  autoResumeAttempts: z7.number().optional(),
+  createdAt: z7.string(),
+  startedAt: z7.string().optional(),
+  finishedAt: z7.string().optional(),
+  tokensUsed: z7.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
-  costUsd: z5.number().optional(),
-  pullRequestUrl: z5.string().optional(),
+  costUsd: z7.number().optional(),
+  pullRequestUrl: z7.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: z5.string().optional(),
+  referencedPullRequestUrl: z7.string().optional(),
   /** The PR/issue number this task is ABOUT (task auto-naming spec) — display tier only. */
-  prNumber: z5.number().optional(),
-  issueNumber: z5.number().optional(),
+  prNumber: z7.number().optional(),
+  issueNumber: z7.number().optional(),
   /** Server-side provenance: referenced-issue discovery currently owns `issueNumber`. */
-  referencedIssueNumberSeeded: z5.boolean().optional(),
+  referencedIssueNumberSeeded: z7.boolean().optional(),
   /** 'user' = renamed via PATCH, never auto-overwritten; 'marker' = agent-declared via
    *  XEZ:TITLE (spec 2026-07-18-task-ref-markers); 'auto' = namer-owned. */
-  titleOrigin: z5.enum(["user", "auto", "marker"]).optional(),
+  titleOrigin: z7.enum(["user", "auto", "marker"]).optional(),
   /** References the agent declared via XEZ:PR/XEZ:ISSUE markers — authoritative over the namer
    *  for the matching kind. */
-  markerRefs: z5.object({ pr: z5.number().optional(), issue: z5.number().optional() }).optional(),
+  markerRefs: z7.object({ pr: z7.number().optional(), issue: z7.number().optional() }).optional(),
   /** The referenced tier's working set (distinct PR URLs spotted, capped server-side). */
-  referencedPrCandidates: z5.array(z5.string()).optional(),
+  referencedPrCandidates: z7.array(z7.string()).optional(),
   /** The issue this task is ABOUT (spec 2026-07-21-report-ref-discovery). Display-only. */
-  referencedIssueUrl: z5.string().optional(),
+  referencedIssueUrl: z7.string().optional(),
   /** The referenced-issue working set, persisted like `referencedPrCandidates`. Capped. */
-  referencedIssueCandidates: z5.array(z5.string()).optional(),
+  referencedIssueCandidates: z7.array(z7.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: z5.literal(false).optional(),
+  worktree: z7.literal(false).optional(),
   /** Absent for in-place runs and after an isolated worktree is removed. */
-  worktreePath: z5.string().optional(),
-  branch: z5.string().optional(),
+  worktreePath: z7.string().optional(),
+  branch: z7.string().optional(),
   /** Stable baseline for session git views: a worktree's fork ref, or an in-place run's starting commit. */
-  baseBranch: z5.string().optional(),
+  baseBranch: z7.string().optional(),
   /** Set when count-based retention (#483) reclaimed the worktree DIRECTORY (the branch is
    *  kept): the dir is gone but recoverable. */
-  worktreeReclaimedAt: z5.string().optional(),
+  worktreeReclaimedAt: z7.string().optional(),
   /** Parallel variants (spec 010): runs sharing a groupId are one group. */
-  groupId: z5.string().optional(),
+  groupId: z7.string().optional(),
   /** Variant letter within the group — 'A' | 'B' | 'C'. */
-  variant: z5.string().optional(),
-  peakRssBytes: z5.number().optional(),
-  peakProcCount: z5.number().optional(),
-  archived: z5.boolean(),
-  archivedAt: z5.string().optional(),
+  variant: z7.string().optional(),
+  peakRssBytes: z7.number().optional(),
+  peakProcCount: z7.number().optional(),
+  archived: z7.boolean(),
+  archivedAt: z7.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: z5.boolean().optional(),
+  pinned: z7.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: z5.string().optional(),
+  pinnedAt: z7.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: z5.string().optional(),
-  currentStepId: z5.string().optional(),
-  error: z5.string().optional(),
-  steps: z5.array(stepStateSchema),
+  seenAt: z7.string().optional(),
+  currentStepId: z7.string().optional(),
+  error: z7.string().optional(),
+  steps: z7.array(stepStateSchema),
   /**
    * The persisted workflow definition, so a `queued` run survives a restart — including the ad-hoc
    * "(planned)" chains that exist nowhere else.
@@ -638,34 +709,34 @@ var runRecordSchema = z5.object({
 var apiRunSchema = runRecordSchema.extend({
   usage: processUsageSchema.optional()
 });
-var runIndexEntrySchema = z5.object({
+var runIndexEntrySchema = z7.object({
   /** The registered project this run belongs to. Joins against `GET /projects`. */
-  projectId: z5.string(),
-  id: z5.string(),
-  title: z5.string(),
-  titleSummary: z5.string().optional(),
-  titleOrigin: z5.enum(["user", "auto", "marker"]).optional(),
+  projectId: z7.string(),
+  id: z7.string(),
+  title: z7.string(),
+  titleSummary: z7.string().optional(),
+  titleOrigin: z7.enum(["user", "auto", "marker"]).optional(),
   status: runStatusSchema,
   activity: runActivitySchema.optional(),
-  createdAt: z5.string(),
-  finishedAt: z5.string().optional(),
+  createdAt: z7.string(),
+  finishedAt: z7.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: z5.string().optional(),
+  seenAt: z7.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: z5.boolean(),
+  archived: z7.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: z5.string().optional(),
+  autoResumeAt: z7.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: z5.string(),
+  workflow: z7.string(),
   /**
    * The backend this run ran as — RESOLVED server-side, in order of how good the evidence is.
    *
@@ -688,12 +759,12 @@ var runIndexEntrySchema = z5.object({
    * the value is what the task WOULD run as — which is why the cockpit renders it muted. Absent
    * means the row is reporting what actually ran.
    */
-  runnerInherited: z5.boolean().optional(),
+  runnerInherited: z7.boolean().optional(),
   /** The model string the run recorded, VERBATIM (`RunRecord.model`). Absent means none was
    *  recorded and the backend picked, which the cockpit prints as a muted `auto` — the same word
    *  the task detail header uses. Never prettified through a catalog: a locally-hosted backend's
    *  own id is the only honest answer. */
-  model: z5.string().optional(),
+  model: z7.string().optional(),
   /**
    * How many DISTINCT backends this run's recorded steps used — a workflow may name one per step.
    *
@@ -702,13 +773,13 @@ var runIndexEntrySchema = z5.object({
    * server-side and reduced to the one number the cell renders (`Claude Code +1`). Absent means
    * one backend or none — which is every ordinary run.
    */
-  stepBackends: z5.number().int().min(2).optional(),
+  stepBackends: z7.number().int().min(2).optional(),
   /** 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: z5.string().optional(),
+  branch: z7.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: z5.string().optional(),
+  startedAt: z7.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
@@ -720,20 +791,20 @@ var runIndexEntrySchema = z5.object({
    * Six scalars is still the slim row this schema exists to keep: `steps[]` and `workflowDef`,
    * the expensive half, stay off it.
    */
-  pullRequestUrl: z5.string().optional(),
-  referencedPullRequestUrl: z5.string().optional(),
-  prNumber: z5.number().optional(),
-  issueNumber: z5.number().optional(),
-  referencedIssueUrl: z5.string().optional(),
-  markerRefs: z5.object({ pr: z5.number().optional(), issue: z5.number().optional() }).optional(),
+  pullRequestUrl: z7.string().optional(),
+  referencedPullRequestUrl: z7.string().optional(),
+  prNumber: z7.number().optional(),
+  issueNumber: z7.number().optional(),
+  referencedIssueUrl: z7.string().optional(),
+  markerRefs: z7.object({ pr: z7.number().optional(), issue: z7.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: z5.number().optional(),
+  costUsd: z7.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: z5.number().optional(),
-  peakProcCount: z5.number().optional(),
+  peakRssBytes: z7.number().optional(),
+  peakProcCount: z7.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.
@@ -745,90 +816,90 @@ var runIndexEntrySchema = z5.object({
    */
   usage: processUsageSchema.optional()
 });
-var referenceStatusesByProjectSchema = z5.record(
-  z5.string(),
-  z5.object({
-    prs: z5.record(z5.number(), referenceStatusSchema),
-    issues: z5.record(z5.number(), referenceStatusSchema)
+var referenceStatusesByProjectSchema = z7.record(
+  z7.string(),
+  z7.object({
+    prs: z7.record(z7.number(), referenceStatusSchema),
+    issues: z7.record(z7.number(), referenceStatusSchema)
   })
 );
-var runsIndexResponseSchema = z5.object({
+var runsIndexResponseSchema = z7.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: z5.array(runIndexEntrySchema),
+  runs: z7.array(runIndexEntrySchema),
   /** Additive: absent statuses mean "nothing warm", never "nothing to show". */
   referenceStatuses: referenceStatusesByProjectSchema,
   /** The per-project cap that produced this list. */
-  perProjectLimit: z5.number(),
+  perProjectLimit: z7.number(),
   /** Ids of the projects that had more runs than the cap allowed. */
-  truncated: z5.array(z5.string())
+  truncated: z7.array(z7.string())
 });
-var createRunResponseSchema = z5.union([
+var createRunResponseSchema = z7.union([
   runRecordSchema,
-  z5.object({ runs: z5.array(runRecordSchema) })
+  z7.object({ runs: z7.array(runRecordSchema) })
 ]);
-var cancelResponseSchema = z5.object({ cancelled: z5.boolean() });
-var cancelAutoResumeResponseSchema = z5.object({ cancelled: z5.literal(true) });
-var archiveFinishedResponseSchema = z5.object({ archived: z5.number() });
-var markAllReadResponseSchema = z5.object({ read: z5.number() });
-var deleteRunResponseSchema = z5.object({ deleted: z5.literal(true) });
-var finishResponseSchema = z5.object({ finished: z5.literal(true) });
-var continueResponseSchema = z5.object({ continued: z5.literal(true) });
-var createPrResponseSchema = z5.object({
-  url: z5.string(),
-  dryRun: z5.boolean()
-});
-var messageResponseSchema = z5.union([
-  z5.object({ delivered: z5.literal(true) }),
-  z5.object({ queued: z5.literal(true), message: queuedMessageSchema }),
-  z5.object({ deferred: z5.literal(true) })
+var cancelResponseSchema = z7.object({ cancelled: z7.boolean() });
+var cancelAutoResumeResponseSchema = z7.object({ cancelled: z7.literal(true) });
+var archiveFinishedResponseSchema = z7.object({ archived: z7.number() });
+var markAllReadResponseSchema = z7.object({ read: z7.number() });
+var deleteRunResponseSchema = z7.object({ deleted: z7.literal(true) });
+var finishResponseSchema = z7.object({ finished: z7.literal(true) });
+var continueResponseSchema = z7.object({ continued: z7.literal(true) });
+var createPrResponseSchema = z7.object({
+  url: z7.string(),
+  dryRun: z7.boolean()
+});
+var messageResponseSchema = z7.union([
+  z7.object({ delivered: z7.literal(true) }),
+  z7.object({ queued: z7.literal(true), message: queuedMessageSchema }),
+  z7.object({ deferred: z7.literal(true) })
 ]);
-var editQueuedMessageResponseSchema = z5.object({ message: queuedMessageSchema });
-var removeQueuedMessageResponseSchema = z5.object({ removed: z5.literal(true) });
-var openInCliResponseSchema = z5.object({
-  opened: z5.literal(true),
-  command: z5.string()
-});
-var removeWorktreeResponseSchema = z5.object({ removed: z5.literal(true) });
-var gitCommitResponseSchema = z5.object({
-  committed: z5.literal(true),
-  sha: z5.string()
-});
-var gitPushResponseSchema = z5.object({
-  pushed: z5.literal(true),
-  branch: z5.string(),
-  remote: z5.string(),
-  upstreamSet: z5.boolean()
-});
-var runCommitSchema = z5.object({
-  sha: z5.string(),
-  subject: z5.string(),
-  author: z5.string(),
+var editQueuedMessageResponseSchema = z7.object({ message: queuedMessageSchema });
+var removeQueuedMessageResponseSchema = z7.object({ removed: z7.literal(true) });
+var openInCliResponseSchema = z7.object({
+  opened: z7.literal(true),
+  command: z7.string()
+});
+var removeWorktreeResponseSchema = z7.object({ removed: z7.literal(true) });
+var gitCommitResponseSchema = z7.object({
+  committed: z7.literal(true),
+  sha: z7.string()
+});
+var gitPushResponseSchema = z7.object({
+  pushed: z7.literal(true),
+  branch: z7.string(),
+  remote: z7.string(),
+  upstreamSet: z7.boolean()
+});
+var runCommitSchema = z7.object({
+  sha: z7.string(),
+  subject: z7.string(),
+  author: z7.string(),
   /** Relative time ("3 hours ago") — git's `%cr`. */
-  when: z5.string()
+  when: z7.string()
 });
-var runCommitsResponseSchema = z5.object({ commits: z5.array(runCommitSchema) });
-var groupVariantSchema = z5.object({
-  id: z5.string(),
+var runCommitsResponseSchema = z7.object({ commits: z7.array(runCommitSchema) });
+var groupVariantSchema = z7.object({
+  id: z7.string(),
   /** 'A' | 'B' | 'C' in practice; `'?'` for a record that lost its letter. */
-  variant: z5.string(),
-  title: z5.string(),
+  variant: z7.string(),
+  title: z7.string(),
   status: runStatusSchema,
-  archived: z5.boolean(),
-  tokensUsed: z5.number(),
+  archived: z7.boolean(),
+  tokensUsed: z7.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
-  costUsd: z5.number().optional(),
-  diffStat: z5.string(),
+  costUsd: z7.number().optional(),
+  diffStat: z7.string(),
   /** First lines of the handoff journal's "## Progress log" section, as markdown. */
-  handoffExcerpt: z5.string()
+  handoffExcerpt: z7.string()
 });
-var groupResponseSchema = z5.object({
-  groupId: z5.string(),
-  runs: z5.array(groupVariantSchema)
+var groupResponseSchema = z7.object({
+  groupId: z7.string(),
+  runs: z7.array(groupVariantSchema)
 });
-var pickVariantResponseSchema = z5.object({
+var pickVariantResponseSchema = z7.object({
   winner: runRecordSchema.optional()
 });
 var FILE_ATTACHMENT_MEDIA_TYPES = [
@@ -851,148 +922,179 @@ function isImageAttachmentName(name) {
   const ext = name.split(".").pop()?.toLowerCase();
   return ext !== void 0 && IMAGE_ATTACHMENT_EXTENSIONS.has(ext);
 }
-var attachmentInputSchema = z5.object({
-  mediaType: z5.string().refine(isAttachmentMediaType, {
+var attachmentInputSchema = z7.object({
+  mediaType: z7.string().refine(isAttachmentMediaType, {
     message: "unsupported attachment type \u2014 images, plain text, markdown and PDF only"
   }),
-  data: z5.string().min(1).max(7e6)
+  data: z7.string().min(1).max(7e6)
 });
 var imageInputSchema = attachmentInputSchema;
-var createRunInputBaseSchema = z5.object({
-  workflow: z5.string().min(1).optional(),
+var createRunInputBaseSchema = z7.object({
+  workflow: z7.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: z5.array(workflowStepDefSchema).min(1).max(8).optional(),
-  task: z5.string().min(1).max(1e5, "must be at most 100000 characters"),
-  model: z5.string().optional(),
+  steps: z7.array(workflowStepDefSchema).min(1).max(8).optional(),
+  task: z7.string().min(1).max(1e5, "must be at most 100000 characters"),
+  model: z7.string().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: z5.string().max(64).optional(),
+  agentProfile: z7.string().max(64).optional(),
   /** 1–3. Above 1 the response is `{ runs }` rather than a single record. */
-  variants: z5.number().int().min(1).max(3).optional(),
+  variants: z7.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: z5.boolean().optional(),
+  worktree: z7.boolean().optional(),
   /** true → autonomous run: never parks at "waiting"; auto-continues until done. */
-  autonomous: z5.boolean().optional(),
+  autonomous: z7.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: z5.boolean().optional(),
+  generateFollowups: z7.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: z5.string().trim().max(2e4, "must be at most 20000 characters").optional().transform((s) => s ? s : void 0),
+  systemPrompt: z7.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: z5.array(attachmentInputSchema).max(4).optional(),
+  images: z7.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: z5.string().min(1).max(200, "must be at most 200 characters").optional()
+  todoId: z7.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 = z5.object({
-  text: z5.string().max(1e5).default(""),
-  images: z5.array(attachmentInputSchema).max(4).default([])
+var messageInputSchema = z7.object({
+  text: z7.string().max(1e5).default(""),
+  images: z7.array(attachmentInputSchema).max(4).default([]),
+  expectedVersion: mcpVersionTokenSchema.optional()
 }).refine((m) => m.text.trim().length > 0 || m.images.length > 0, {
   message: "message needs text or at least one attachment"
 });
-var patchRunInputSchema = z5.object({
-  title: z5.string().trim().min(1).max(300).optional(),
-  task: z5.string().trim().min(1).max(1e5).optional()
+var patchRunInputSchema = z7.object({
+  title: z7.string().trim().min(1).max(300).optional(),
+  task: z7.string().trim().min(1).max(1e5).optional(),
+  expectedVersion: mcpVersionTokenSchema.optional()
+});
+var runVersionGuardInputSchema = z7.object({
+  expectedVersion: mcpVersionTokenSchema.optional()
 });
+var pickVariantInputSchema = runVersionGuardInputSchema.extend({
+  runId: z7.string().min(1)
+});
+var archiveRunInputSchema = runVersionGuardInputSchema.extend({
+  archived: z7.boolean().optional()
+});
+var pinRunInputSchema = runVersionGuardInputSchema.extend({
+  pinned: z7.boolean().optional()
+});
+var queuedMessagePatchInputSchema = runVersionGuardInputSchema.extend({
+  text: z7.string().max(1e5).optional(),
+  images: z7.array(attachmentInputSchema).max(4).optional()
+}).refine((m) => m.text !== void 0 || m.images !== void 0, {
+  message: "message edit needs text or attachments"
+});
+var continueRunInputSchema = runVersionGuardInputSchema.extend({
+  text: z7.string().max(1e5, "must be at most 100000 characters").optional(),
+  images: z7.array(attachmentInputSchema).max(4).optional(),
+  runner: runnerSchema.optional(),
+  model: z7.string().max(200).optional(),
+  agentProfile: z7.string().max(64).optional()
+});
+var gitCommitInputSchema = runVersionGuardInputSchema.extend({
+  message: z7.string().trim().min(1, "must not be empty").max(5e3)
+});
+var runVersionResponseSchema = z7.object({ version: mcpVersionTokenSchema });
 
 // ../contract/src/repo.ts
-import { z as z6 } from "zod";
-var statusEntrySchema = z6.object({
-  status: z6.string(),
-  path: z6.string()
+import { z as z8 } from "zod";
+var statusEntrySchema = z8.object({
+  status: z8.string(),
+  path: z8.string()
 });
-var logEntrySchema = z6.object({
-  hash: z6.string(),
-  subject: z6.string(),
-  author: z6.string(),
-  when: z6.string()
-});
-var repoResponseSchema = z6.union([
-  z6.object({
-    info: z6.null(),
-    status: z6.array(z6.never()),
-    log: z6.array(z6.never()),
-    branches: z6.array(z6.never()),
-    baseBranch: z6.null()
+var logEntrySchema = z8.object({
+  hash: z8.string(),
+  subject: z8.string(),
+  author: z8.string(),
+  when: z8.string()
+});
+var repoResponseSchema = z8.union([
+  z8.object({
+    info: z8.null(),
+    status: z8.array(z8.never()),
+    log: z8.array(z8.never()),
+    branches: z8.array(z8.never()),
+    baseBranch: z8.null()
   }),
-  z6.object({
+  z8.object({
     info: repoInfoSchema,
-    status: z6.array(statusEntrySchema),
-    log: z6.array(logEntrySchema),
-    branches: z6.array(z6.string()),
-    baseBranch: z6.string().nullable()
+    status: z8.array(statusEntrySchema),
+    log: z8.array(logEntrySchema),
+    branches: z8.array(z8.string()),
+    baseBranch: z8.string().nullable()
   })
 ]);
-var repoBranchResponseSchema = z6.object({
-  branch: z6.string(),
-  created: z6.boolean()
+var repoBranchResponseSchema = z8.object({
+  branch: z8.string(),
+  created: z8.boolean()
 });
-var diffStatSchema2 = z6.object({
-  adds: z6.number(),
-  dels: z6.number(),
-  files: z6.number()
+var diffStatSchema2 = z8.object({
+  adds: z8.number(),
+  dels: z8.number(),
+  files: z8.number()
 });
-var changedFileSchema = z6.object({
-  path: z6.string(),
+var changedFileSchema = z8.object({
+  path: z8.string(),
   /** Rename/copy source — present only when `status` is renamed/copied. */
-  oldPath: z6.string().optional(),
-  status: z6.enum(["added", "modified", "deleted", "renamed", "copied"]),
-  adds: z6.number(),
-  dels: z6.number(),
+  oldPath: z8.string().optional(),
+  status: z8.enum(["added", "modified", "deleted", "renamed", "copied"]),
+  adds: z8.number(),
+  dels: z8.number(),
   /** Binary per numstat — there is no text patch to render. */
-  binary: z6.boolean(),
+  binary: z8.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: z6.boolean().optional(),
+  image: z8.boolean().optional(),
   /** This file's unified-diff section; possibly `… (patch truncated)`, possibly empty. */
-  patch: z6.string()
+  patch: z8.string()
 });
-var changesPayloadSchema = z6.object({
-  files: z6.array(changedFileSchema),
+var changesPayloadSchema = z8.object({
+  files: z8.array(changedFileSchema),
   stat: diffStatSchema2,
   /** Additive context for review tasks whose worktree HEAD no longer matches their own branch. */
-  repointedHead: z6.object({ headBranch: z6.string(), taskBranch: z6.string() }).optional()
+  repointedHead: z8.object({ headBranch: z8.string(), taskBranch: z8.string() }).optional()
 });
-var repoCommitPayloadSchema = z6.object({
-  sha: z6.string(),
-  subject: z6.string(),
-  author: z6.string(),
+var repoCommitPayloadSchema = z8.object({
+  sha: z8.string(),
+  subject: z8.string(),
+  author: z8.string(),
   /** Relative time ("3 hours ago") — same `%cr` format as the /api/v1/repo log. */
-  when: z6.string(),
-  files: z6.array(changedFileSchema),
+  when: z8.string(),
+  files: z8.array(changedFileSchema),
   stat: diffStatSchema2
 });
-var worktreeDirEntrySchema = z6.object({
-  name: z6.string(),
-  type: z6.enum(["dir", "file"]),
-  size: z6.number().optional()
-});
-var worktreeEntrySchema = z6.discriminatedUnion("type", [
-  z6.object({
-    type: z6.literal("dir"),
-    path: z6.string(),
-    entries: z6.array(worktreeDirEntrySchema)
+var worktreeDirEntrySchema = z8.object({
+  name: z8.string(),
+  type: z8.enum(["dir", "file"]),
+  size: z8.number().optional()
+});
+var worktreeEntrySchema = z8.discriminatedUnion("type", [
+  z8.object({
+    type: z8.literal("dir"),
+    path: z8.string(),
+    entries: z8.array(worktreeDirEntrySchema)
   }),
-  z6.object({
-    type: z6.literal("file"),
-    path: z6.string(),
-    size: z6.number(),
-    binary: z6.boolean(),
-    tooLarge: z6.boolean(),
-    content: z6.string().optional()
+  z8.object({
+    type: z8.literal("file"),
+    path: z8.string(),
+    size: z8.number(),
+    binary: z8.boolean(),
+    tooLarge: z8.boolean(),
+    content: z8.string().optional()
   })
 ]);
-var worktreeRunStatusSchema = z6.enum([
+var worktreeRunStatusSchema = z8.enum([
   "queued",
   "running",
   "waiting",
@@ -1001,41 +1103,41 @@ var worktreeRunStatusSchema = z6.enum([
   "failed",
   "cancelled"
 ]);
-var worktreeInfoSchema = z6.object({
-  runId: z6.string(),
-  title: z6.string(),
+var worktreeInfoSchema = z8.object({
+  runId: z8.string(),
+  title: z8.string(),
   status: worktreeRunStatusSchema,
-  branch: z6.string().nullable(),
-  sizeBytes: z6.number().nullable(),
-  finishedAt: z6.string().nullable(),
-  reclaimable: z6.boolean()
+  branch: z8.string().nullable(),
+  sizeBytes: z8.number().nullable(),
+  finishedAt: z8.string().nullable(),
+  reclaimable: z8.boolean()
 });
-var worktreesResponseSchema = z6.object({
-  worktrees: z6.array(worktreeInfoSchema),
-  totalBytes: z6.number().nullable(),
-  keep: z6.number()
+var worktreesResponseSchema = z8.object({
+  worktrees: z8.array(worktreeInfoSchema),
+  totalBytes: z8.number().nullable(),
+  keep: z8.number()
 });
-var reclaimWorktreesResponseSchema = z6.object({
-  reclaimed: z6.array(z6.string())
+var reclaimWorktreesResponseSchema = z8.object({
+  reclaimed: z8.array(z8.string())
 });
 
 // ../contract/src/projects.ts
-import { z as z7 } from "zod";
-var projectListEntrySchema = z7.object({
-  id: z7.string(),
-  name: z7.string(),
+import { z as z9 } from "zod";
+var projectListEntrySchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
   /** Absolute, realpath-normalized repo root. */
-  root: z7.string(),
-  addedAt: z7.string(),
-  lastOpenedAt: z7.string(),
-  source: z7.enum(["local", "checkout"]),
+  root: z9.string(),
+  addedAt: z9.string(),
+  lastOpenedAt: z9.string(),
+  source: z9.enum(["local", "checkout"]),
   /** `not-git` is fully usable (degraded single-queue mode); only `missing` blocks. */
-  status: z7.enum(["ok", "missing", "not-git"]),
+  status: z9.enum(["ok", "missing", "not-git"]),
   /** Current branch when cheaply available (omitted e.g. on an unborn HEAD). */
-  branch: z7.string().optional(),
+  branch: z9.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(),
+  forge: z9.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
@@ -1045,10 +1147,10 @@ var projectListEntrySchema = z7.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: z7.string().optional(),
+  repoUrl: z9.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: z7.number().optional(),
+  maxParallel: z9.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.
@@ -1060,100 +1162,100 @@ var projectListEntrySchema = z7.object({
    * server-side (trimmed, deduped case-insensitively, sorted), so a consumer may compare them
    * directly.
    */
-  tags: z7.array(z7.string()).optional()
+  tags: z9.array(z9.string()).optional()
 });
-var projectsResponseSchema = z7.object({
-  projects: z7.array(projectListEntrySchema),
-  bootProject: z7.string(),
-  projectsDir: z7.string()
+var projectsResponseSchema = z9.object({
+  projects: z9.array(projectListEntrySchema),
+  bootProject: z9.string(),
+  projectsDir: z9.string()
 });
-var registerProjectResponseSchema = z7.object({
+var registerProjectResponseSchema = z9.object({
   project: projectListEntrySchema,
-  error: z7.string().optional()
+  error: z9.string().optional()
 });
-var removeProjectResponseSchema = z7.object({
-  removed: z7.literal(true),
-  id: z7.string()
+var removeProjectResponseSchema = z9.object({
+  removed: z9.literal(true),
+  id: z9.string()
 });
-var updateProjectResponseSchema = z7.object({
+var updateProjectResponseSchema = z9.object({
   project: projectListEntrySchema
 });
 var PROJECT_TAG_MAX_LENGTH = 32;
 var PROJECT_TAGS_MAX = 20;
-var updateProjectInputSchema = z7.object({
-  maxParallel: z7.number().int().min(1).max(16).nullable().optional(),
-  tags: z7.array(z7.string().trim().min(1).max(PROJECT_TAG_MAX_LENGTH)).max(PROJECT_TAGS_MAX).nullable().optional()
+var updateProjectInputSchema = z9.object({
+  maxParallel: z9.number().int().min(1).max(16).nullable().optional(),
+  tags: z9.array(z9.string().trim().min(1).max(PROJECT_TAG_MAX_LENGTH)).max(PROJECT_TAGS_MAX).nullable().optional()
 }).refine(
   (body) => body.maxParallel !== void 0 || body.tags !== void 0,
   "specify maxParallel or tags"
 );
-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 checkoutProjectInputSchema = z9.object({
+  url: z9.string().trim().min(1).max(512),
+  name: z9.string().trim().max(128).optional(),
+  checkoutId: z9.string().trim().max(128).optional()
 });
-var fsBrowseDirSchema = z7.object({
-  name: z7.string(),
-  path: z7.string(),
+var fsBrowseDirSchema = z9.object({
+  name: z9.string(),
+  path: z9.string(),
   /** Has a `.git` entry — drives the "git" badge. A non-repo folder is still selectable. */
-  isRepo: z7.boolean()
+  isRepo: z9.boolean()
 });
-var fsBrowseResponseSchema = z7.object({
+var fsBrowseResponseSchema = z9.object({
   /** The realpath'd directory actually listed — never the spelling asked for, so the breadcrumb
    *  shows where the picker really is. */
-  path: z7.string(),
+  path: z9.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),
+  parent: z9.string().nullable(),
+  dirs: z9.array(fsBrowseDirSchema),
   /** True when the listing was capped server-side — surfaced honestly instead of showing a
    *  silently short list. */
-  truncated: z7.boolean()
+  truncated: z9.boolean()
 });
-var launchKeyResponseSchema = z7.object({
-  key: z7.string()
+var launchKeyResponseSchema = z9.object({
+  key: z9.string()
 });
 
 // ../contract/src/workspace.ts
-import { z as z8 } from "zod";
-var workspaceConfigResponseSchema = z8.object({
+import { z as z10 } from "zod";
+var workspaceConfigResponseSchema = z10.object({
   /** Root exposed by the Add-project directory browser — stored as written (`~` kept). */
-  browseRoot: z8.string(),
+  browseRoot: z10.string(),
   /** Checkout root for GUI-cloned projects — stored as written (`~` kept). */
-  projectsDir: z8.string(),
+  projectsDir: z10.string(),
   /** Stored override; `null` means inherit `XEZ_SKILLS_AUTO_UPDATE`, then true. */
-  skillsAutoUpdate: z8.boolean().nullable(),
-  effectiveSkillsAutoUpdate: z8.boolean(),
+  skillsAutoUpdate: z10.boolean().nullable(),
+  effectiveSkillsAutoUpdate: z10.boolean(),
   /** Stored follow-up Inbox override (F); `null` = no stored key, `XEZ_FOLLOWUPS` decides. */
-  followups: z8.boolean().nullable(),
+  followups: z10.boolean().nullable(),
   /** What `followups` + the env actually resolve to right now — what the cockpit shows. */
-  effectiveFollowups: z8.boolean(),
+  effectiveFollowups: z10.boolean(),
   /** Stored extra agent env-passthrough names (F); `null` = no stored key,
    *  `XEZ_ENV_PASSTHROUGH` decides. `[]` is a real stored "forward nothing". */
-  agentEnvPassthrough: z8.array(z8.string()).nullable(),
+  agentEnvPassthrough: z10.array(z10.string()).nullable(),
   /** What `agentEnvPassthrough` + the env actually resolve to right now. */
-  effectiveAgentEnvPassthrough: z8.array(z8.string()),
-  composerDefaults: z8.object({
-    autonomous: z8.boolean().nullable(),
-    worktree: z8.boolean().nullable(),
+  effectiveAgentEnvPassthrough: z10.array(z10.string()),
+  composerDefaults: z10.object({
+    autonomous: z10.boolean().nullable(),
+    worktree: z10.boolean().nullable(),
     /** `'source-dependent'` when no `XEZ_AUTONOMOUS_DEFAULT` pins it either way. */
-    inheritedAutonomous: z8.union([z8.boolean(), z8.literal("source-dependent")]),
-    inheritedWorktree: z8.boolean()
+    inheritedAutonomous: z10.union([z10.boolean(), z10.literal("source-dependent")]),
+    inheritedWorktree: z10.boolean()
   }),
-  resources: z8.object({
-    maxParallel: z8.number(),
-    maxMonitoringSessions: z8.number(),
-    monitoringWakeIntervalMinutes: z8.number().nullable(),
+  resources: z10.object({
+    maxParallel: z10.number(),
+    maxMonitoringSessions: z10.number(),
+    monitoringWakeIntervalMinutes: z10.number().nullable(),
     /** Resume a run a provider usage limit stopped, once the limit resets. Default `true`. */
-    autoResumeOnUsageLimit: z8.boolean(),
+    autoResumeOnUsageLimit: z10.boolean(),
     /** Wall clock for a session parked at `waiting`, in minutes; `null` = never close on
      *  idle. Default 15. */
-    idleTimeoutMinutes: z8.number().nullable(),
-    memoryLimitMb: z8.number().nullable(),
+    idleTimeoutMinutes: z10.number().nullable(),
+    memoryLimitMb: z10.number().nullable(),
     /** The host-derived ceiling an ABSENT `memoryLimitMb` falls back to (B1) — reported so
      *  the settings pane can name the machine's own default instead of guessing it. */
-    memoryLimitDefaultMb: z8.number(),
-    worktreeRetentionDefault: z8.number()
+    memoryLimitDefaultMb: z10.number(),
+    worktreeRetentionDefault: z10.number()
   }),
   /**
    * What a repo that has set none of its own runs (spec 2026-07-29-agent-profiles).
@@ -1163,125 +1265,125 @@ var workspaceConfigResponseSchema = z8.object({
    * from a value someone chose or the fallback collapses into "always claude". Consulted only where
    * the repo's own `.xezar/config.json` is silent — a repo that chose is never overruled.
    */
-  agentDefaults: z8.object({
+  agentDefaults: z10.object({
     runner: runnerSchema.optional(),
-    models: z8.object({
-      claude: z8.string().optional(),
-      codex: z8.string().optional(),
-      opencode: z8.string().optional(),
-      pi: z8.string().optional()
+    models: z10.object({
+      claude: z10.string().optional(),
+      codex: z10.string().optional(),
+      opencode: z10.string().optional(),
+      pi: z10.string().optional()
     }).optional()
   })
 });
-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(),
+var setWorkspaceConfigInputSchema = z10.object({
+  browseRoot: z10.string().trim().min(1).max(4096).optional(),
+  projectsDir: z10.string().trim().min(1).max(4096).optional(),
+  skillsAutoUpdate: z10.boolean().nullable().optional(),
   /** Stored Inbox override (F): `null` clears the key back to the `XEZ_FOLLOWUPS` default. */
-  followups: z8.boolean().nullable().optional(),
+  followups: z10.boolean().nullable().optional(),
   /** Stored env-passthrough names (F): `null` clears the key back to the
    *  `XEZ_ENV_PASSTHROUGH` default; `[]` stores a real "forward nothing". */
-  agentEnvPassthrough: z8.array(z8.string().trim().min(1).max(200)).max(64).nullable().optional(),
-  composerDefaults: z8.object({
-    autonomous: z8.boolean().nullable().optional(),
-    worktree: z8.boolean().nullable().optional()
+  agentEnvPassthrough: z10.array(z10.string().trim().min(1).max(200)).max(64).nullable().optional(),
+  composerDefaults: z10.object({
+    autonomous: z10.boolean().nullable().optional(),
+    worktree: z10.boolean().nullable().optional()
   }).optional(),
   /** Machine-wide agent defaults. `null` on a key CLEARS it back to "no opinion", which a bare
    *  absent key cannot say in a partial patch. */
-  agentDefaults: z8.object({
+  agentDefaults: z10.object({
     runner: runnerSchema.nullable().optional(),
-    models: z8.object({
-      claude: z8.string().trim().min(1).max(200).nullable().optional(),
-      codex: z8.string().trim().min(1).max(200).nullable().optional(),
-      opencode: z8.string().trim().min(1).max(200).nullable().optional(),
-      pi: z8.string().trim().min(1).max(200).nullable().optional()
+    models: z10.object({
+      claude: z10.string().trim().min(1).max(200).nullable().optional(),
+      codex: z10.string().trim().min(1).max(200).nullable().optional(),
+      opencode: z10.string().trim().min(1).max(200).nullable().optional(),
+      pi: z10.string().trim().min(1).max(200).nullable().optional()
     }).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(),
-    autoResumeOnUsageLimit: z8.boolean().optional(),
+  resources: z10.object({
+    maxParallel: z10.number().int().min(1).max(16).optional(),
+    maxMonitoringSessions: z10.number().int().min(0).max(16).optional(),
+    monitoringWakeIntervalMinutes: z10.number().int().min(1).max(60).nullable().optional(),
+    autoResumeOnUsageLimit: z10.boolean().optional(),
     /** `null` = never close an idle session; a number is minutes (1 to 1440). */
-    idleTimeoutMinutes: z8.number().int().min(1).max(1440).nullable().optional(),
-    memoryLimitMb: z8.number().int().min(0).max(1048576).nullable().optional(),
-    worktreeRetentionDefault: z8.number().int().min(0).max(1e3).optional()
+    idleTimeoutMinutes: z10.number().int().min(1).max(1440).nullable().optional(),
+    memoryLimitMb: z10.number().int().min(0).max(1048576).nullable().optional(),
+    worktreeRetentionDefault: z10.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(),
-  width: z8.enum(["narrow", "wide"]).optional()
+var appearanceSchema = z10.object({
+  accent: z10.enum(["lime", "violet"]).optional(),
+  density: z10.enum(["comfortable", "compact", "ultra"]).optional(),
+  width: z10.enum(["narrow", "wide"]).optional()
 });
-var taskTableUiStateSchema = z8.looseObject({
+var taskTableUiStateSchema = z10.looseObject({
   /** Explicit user choices only. Missing ids keep the registry-owned default. */
-  expandedColumns: z8.record(z8.string(), z8.boolean()).optional()
+  expandedColumns: z10.record(z10.string(), z10.boolean()).optional()
 });
-var uiStateSchema = z8.looseObject({
+var uiStateSchema = z10.looseObject({
   /** 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
    *  run has been recorded here" — a cockpit reading either one selects nothing. */
-  lastTask: z8.object({ source: z8.enum(["workflow", "skill"]), ref: z8.string() }).nullable().optional(),
+  lastTask: z10.object({ source: z10.enum(["workflow", "skill"]), ref: z10.string() }).nullable().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(),
+  recentSources: z10.array(z10.object({ source: z10.enum(["workflow", "skill"]), ref: z10.string() })).optional(),
   /** The last worktree choice for a single-skill run. Absent → the default (isolated worktree). */
-  lastWorktree: z8.boolean().optional(),
+  lastWorktree: z10.boolean().optional(),
   /** The last autonomous choice — remembered like `lastWorktree`. Absent → off. */
-  lastAutonomous: z8.boolean().optional(),
+  lastAutonomous: z10.boolean().optional(),
   /** Whether new runs should ask agents to append follow-up work. Absent → on. */
-  lastGenerateFollowups: z8.boolean().optional(),
+  lastGenerateFollowups: z10.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(),
+  skillUsage: z10.record(z10.string(), z10.number()).optional(),
+  runsView: z10.enum(["list", "table"]).optional(),
   /** The GitHub tab's last-selected sub-tab (#417). Absent → issues. */
-  githubView: z8.enum(["issues", "prs"]).optional(),
+  githubView: z10.enum(["issues", "prs"]).optional(),
   /** Settings → Appearance. The theme itself stays in localStorage (`xez-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()
+  promptTemplates: z10.array(
+    z10.object({
+      id: z10.string(),
+      label: z10.string(),
+      text: z10.string(),
+      skills: z10.array(z10.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()
+  dismissedSkillsBanner: z10.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 workspaceLastLocationSchema = z10.strictObject({
+  projectId: z10.string().min(1).max(64),
+  pathname: z10.string().min(1).max(2048).startsWith("/p/"),
+  search: z10.string().max(4096).startsWith("?").optional(),
+  hash: z10.string().max(2048).startsWith("#").optional()
 });
-var workspaceUiStateSchema = z8.looseObject({
+var workspaceUiStateSchema = z10.looseObject({
   /** LEGACY — the sidebar's per-project collapse map (step 3.3). Still accepted and still
    *  round-tripped so an older cockpit sharing this home keeps working, but the current cockpit
    *  neither reads nor writes it: which groups are shut describes the WINDOW, not the workspace,
    *  so it lives in that browser's localStorage (`packages/web/src/lib/sidebar-collapse.ts`).
    *  One shared answer meant a phone collapsing a group collapsed it on the desktop too. */
-  sidebar: z8.looseObject({ collapsed: z8.record(z8.string(), z8.boolean()).optional() }).optional(),
+  sidebar: z10.looseObject({ collapsed: z10.record(z10.string(), z10.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(),
-    pi: z8.string().optional()
+  dismissedProviderAuthFailures: z10.object({
+    claude: z10.string().optional(),
+    codex: z10.string().optional(),
+    opencode: z10.string().optional(),
+    pi: z10.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(),
+  notifications: z10.looseObject({ enabled: z10.boolean().optional() }).optional(),
   /** Desktop Tasks-table density, shared across every project in this workspace. */
   taskTable: taskTableUiStateSchema.optional(),
   /** LEGACY, exactly like `sidebar` above — the last settled project-scoped page, restored when
@@ -1292,26 +1394,26 @@ var workspaceUiStateSchema = z8.looseObject({
   /** 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()
+  importedSkills: z10.array(z10.string()).optional()
 });
 var WORKSPACE_UI_STATE_MAX_KEYS = 200;
 var TASK_TABLE_MAX_COLUMNS = 50;
-var setWorkspaceUiStateInputSchema = z8.looseObject({
+var setWorkspaceUiStateInputSchema = z10.looseObject({
   ...workspaceUiStateSchema.shape,
-  sidebar: z8.looseObject({
-    collapsed: z8.record(z8.string().min(1).max(64), z8.boolean()).refine((map) => Object.keys(map).length <= WORKSPACE_UI_STATE_MAX_KEYS, {
+  sidebar: z10.looseObject({
+    collapsed: z10.record(z10.string().min(1).max(64), z10.boolean()).refine((map) => Object.keys(map).length <= WORKSPACE_UI_STATE_MAX_KEYS, {
       message: `sidebar.collapsed must have at most ${WORKSPACE_UI_STATE_MAX_KEYS} entries`
     }).optional()
   }).optional(),
-  dismissedProviderAuthFailures: z8.strictObject({
-    claude: z8.string().min(1).max(128).optional(),
-    codex: z8.string().min(1).max(128).optional(),
-    opencode: z8.string().min(1).max(128).optional(),
-    pi: z8.string().min(1).max(128).optional()
+  dismissedProviderAuthFailures: z10.strictObject({
+    claude: z10.string().min(1).max(128).optional(),
+    codex: z10.string().min(1).max(128).optional(),
+    opencode: z10.string().min(1).max(128).optional(),
+    pi: z10.string().min(1).max(128).optional()
   }).optional(),
-  importedSkills: z8.array(z8.string().min(1).max(200)).max(WORKSPACE_UI_STATE_MAX_KEYS).optional(),
+  importedSkills: z10.array(z10.string().min(1).max(200)).max(WORKSPACE_UI_STATE_MAX_KEYS).optional(),
   taskTable: taskTableUiStateSchema.extend({
-    expandedColumns: z8.record(z8.string().min(1).max(64), z8.boolean()).refine((map) => Object.keys(map).length <= TASK_TABLE_MAX_COLUMNS, {
+    expandedColumns: z10.record(z10.string().min(1).max(64), z10.boolean()).refine((map) => Object.keys(map).length <= TASK_TABLE_MAX_COLUMNS, {
       message: `taskTable.expandedColumns must have at most ${TASK_TABLE_MAX_COLUMNS} entries`
     }).optional()
   }).optional()
@@ -1323,73 +1425,73 @@ var setWorkspaceUiStateInputSchema = z8.looseObject({
     });
   }
 });
-var runnerModelsSchema = z8.object({
-  claude: z8.string().optional(),
-  codex: z8.string().optional(),
-  opencode: z8.string().optional(),
-  pi: z8.string().optional()
+var runnerModelsSchema = z10.object({
+  claude: z10.string().optional(),
+  codex: z10.string().optional(),
+  opencode: z10.string().optional(),
+  pi: z10.string().optional()
 });
-var configResponseSchema = z8.object({
-  baseBranch: z8.string().nullable(),
+var configResponseSchema = z10.object({
+  baseBranch: z10.string().nullable(),
   defaultRunner: runnerSchema,
-  systemPrompt: z8.string().nullable(),
+  systemPrompt: z10.string().nullable(),
   defaultModels: runnerModelsSchema,
   /** True when native coding-agent settings are authoritative and model picks are read-only. */
-  modelsLocked: z8.boolean(),
+  modelsLocked: z10.boolean(),
   /** How many tasks run at once (1–16). */
-  maxParallel: z8.number(),
+  maxParallel: z10.number(),
   /** Per-task memory ceiling in MiB (whole process tree); null = no limit. */
-  memoryLimitMb: z8.number().nullable(),
+  memoryLimitMb: z10.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(),
+  worktreeRetention: z10.number(),
   /** Live title updates: null = no config key, the `XEZ_TITLE_UPDATES` env default (ON) decides. */
-  liveTitleUpdates: z8.boolean().nullable(),
+  liveTitleUpdates: z10.boolean().nullable(),
   /** Optional review gate (#489): null = no config key, the `XEZ_REVIEW_GATE` env default (OFF)
    *  decides. */
-  reviewGate: z8.boolean().nullable(),
+  reviewGate: z10.boolean().nullable(),
   /** Model the chain planner runs on (Claude aliases only; other backends pick their own).
    *  Always materialized — the file schema defaults it to `sonnet` (E). */
-  plannerModel: z8.string(),
+  plannerModel: z10.string(),
   /** Model the task namer runs on, same rule as `plannerModel`. Defaults to `haiku` (E). */
-  namerModel: z8.string(),
+  namerModel: z10.string(),
   /** Team skill sources (E). Always materialized: the file schema defaults it to the shared
    *  catalog, and `[]` is a real "no team skills" choice. */
-  skillsRepos: z8.array(z8.object({ repo: z8.string(), ref: z8.string() }))
+  skillsRepos: z10.array(z10.object({ repo: z10.string(), ref: z10.string() }))
 });
 var setConfigResponseSchema = configResponseSchema;
-var setConfigInputSchema = z8.object({
-  baseBranch: z8.string().trim().min(1).max(200).nullable().optional(),
+var setConfigInputSchema = z10.object({
+  baseBranch: z10.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(),
-    pi: z8.string().trim().max(200).nullable().optional()
+  systemPrompt: z10.string().trim().max(2e4).nullable().optional(),
+  defaultModels: z10.object({
+    claude: z10.string().trim().max(200).nullable().optional(),
+    codex: z10.string().trim().max(200).nullable().optional(),
+    opencode: z10.string().trim().max(200).nullable().optional(),
+    pi: z10.string().trim().max(200).nullable().optional()
   }).optional(),
-  maxParallel: z8.number().int().min(1).max(16).optional(),
+  maxParallel: z10.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(),
+  memoryLimitMb: z10.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(),
+  worktreeRetention: z10.number().int().min(0).max(1e3).nullable().optional(),
   /** null clears the key back to the env-default behavior. */
-  liveTitleUpdates: z8.boolean().nullable().optional(),
+  liveTitleUpdates: z10.boolean().nullable().optional(),
   /** null clears the key back to the env-default behavior (OFF). */
-  reviewGate: z8.boolean().nullable().optional(),
+  reviewGate: z10.boolean().nullable().optional(),
   /** `null` clears the key back to the schema default (`sonnet`). */
-  plannerModel: z8.string().trim().min(1).max(200).nullable().optional(),
+  plannerModel: z10.string().trim().min(1).max(200).nullable().optional(),
   /** `null` clears the key back to the schema default (`haiku`). */
-  namerModel: z8.string().trim().min(1).max(200).nullable().optional(),
+  namerModel: z10.string().trim().min(1).max(200).nullable().optional(),
   /** `null` clears the key back to the default catalog; `[]` disables team skills. */
-  skillsRepos: z8.array(
-    z8.object({
-      repo: z8.string().trim().min(1).max(500),
-      ref: z8.string().trim().min(1).max(200).optional()
+  skillsRepos: z10.array(
+    z10.object({
+      repo: z10.string().trim().min(1).max(500),
+      ref: z10.string().trim().min(1).max(200).optional()
     })
   ).max(32).nullable().optional()
 });
-var skillsUpdateStatusSchema = z8.enum([
+var skillsUpdateStatusSchema = z10.enum([
   "idle",
   "checking",
   "available",
@@ -1398,224 +1500,224 @@ var skillsUpdateStatusSchema = z8.enum([
   "unavailable",
   "error"
 ]);
-var skillsUpdateScopeStateSchema = z8.object({
-  scope: z8.enum(["project", "global"]),
+var skillsUpdateScopeStateSchema = z10.object({
+  scope: z10.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()
+  available: z10.boolean(),
+  skills: z10.array(z10.string()),
+  checkedAt: z10.string().nullable(),
+  updatedAt: z10.string().nullable(),
+  reason: z10.string().optional()
 });
-var skillsUpdateStateSchema = z8.object({
+var skillsUpdateStateSchema = z10.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()
+  available: z10.boolean(),
+  autoUpdateEnabled: z10.boolean(),
+  inherited: z10.boolean(),
+  checkedAt: z10.string().nullable(),
+  updatedAt: z10.string().nullable(),
+  scopes: z10.array(skillsUpdateScopeStateSchema),
+  needsUpgradeNotes: z10.boolean()
 });
 var providerIdSchema = runnerSchema;
-var providerConnectionStateSchema = z8.enum([
+var providerConnectionStateSchema = z10.enum([
   "connected",
   "disconnected",
   "not-installed",
   "unknown"
 ]);
-var providerStatusSchema = z8.object({
+var providerStatusSchema = z10.object({
   provider: providerIdSchema,
   status: providerConnectionStateSchema,
-  enabled: z8.boolean().optional(),
-  hint: z8.string().optional(),
-  authFailureId: z8.string().optional(),
+  enabled: z10.boolean().optional(),
+  hint: z10.string().optional(),
+  authFailureId: z10.string().optional(),
   /** Which agent account this row describes (spec 2026-07-29-agent-profiles). ABSENT on
    *  `GET /api/v1/providers/status`, which deliberately keeps answering exactly one row per
    *  provider — the discovered default — so an older client sees no change at all. Per-account
    *  rows are carried by `GET /api/v1/workspace/agent-profiles` instead. */
-  profileId: z8.string().optional()
+  profileId: z10.string().optional()
 });
-var providerStatusResponseSchema = z8.object({
-  providers: z8.array(providerStatusSchema)
+var providerStatusResponseSchema = z10.object({
+  providers: z10.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 providerConnectResponseSchema = z10.discriminatedUnion("opened", [
+  z10.object({ opened: z10.literal(true), command: z10.string() }),
+  z10.object({ opened: z10.literal(false), connected: z10.literal(true), command: z10.string() })
 ]);
-var modelDiscoveryRunnerSchema = z8.enum(["claude", "codex", "opencode", "pi"]);
+var modelDiscoveryRunnerSchema = z10.enum(["claude", "codex", "opencode", "pi"]);
 var MODEL_DISCOVERY_RUNNERS = modelDiscoveryRunnerSchema.options;
 function runnerDiscoversModels(runner) {
   return MODEL_DISCOVERY_RUNNERS.includes(runner);
 }
-var runnerModelOptionSchema = z8.object({
-  id: z8.string(),
-  label: z8.string(),
-  description: z8.string()
+var runnerModelOptionSchema = z10.object({
+  id: z10.string(),
+  label: z10.string(),
+  description: z10.string()
 });
-var runnerModelCatalogResponseSchema = z8.object({
+var runnerModelCatalogResponseSchema = z10.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(),
+  models: z10.array(runnerModelOptionSchema),
+  source: z10.enum(["live", "cache", "unavailable"]),
+  stale: z10.boolean(),
+  reason: z10.string().optional()
+});
+var openTargetSchema = z10.object({
+  id: z10.string(),
+  label: z10.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()
+  icon: z10.string().optional()
 });
-var openTargetsResponseSchema = z8.object({
-  targets: z8.array(openTargetSchema)
+var openTargetsResponseSchema = z10.object({
+  targets: z10.array(openTargetSchema)
 });
-var openProjectInSchema = z8.object({
+var openProjectInSchema = z10.object({
   // A short bound (#429): matched against a downstream allowlist, so an app id is never long.
-  target: z8.string().trim().min(1, "target required").max(200)
+  target: z10.string().trim().min(1, "target required").max(200)
 });
-var openProjectInResponseSchema = z8.object({
-  opened: z8.literal(true),
-  path: z8.string()
+var openProjectInResponseSchema = z10.object({
+  opened: z10.literal(true),
+  path: z10.string()
 });
 
 // ../contract/src/skills.ts
-import { z as z9 } from "zod";
-var skillSchema = z9.object({
-  name: z9.string(),
-  description: z9.string().optional(),
+import { z as z11 } from "zod";
+var skillSchema = z11.object({
+  name: z11.string(),
+  description: z11.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", "xezar", "agents", "global", "team"]),
+  interactive: z11.literal(true).optional(),
+  body: z11.string(),
+  path: z11.string(),
+  source: z11.enum(["ai", "xezar", "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(),
+  team: z11.object({
+    repo: z11.string(),
+    ref: z11.string(),
+    path: z11.string(),
     /** True for the `SKILL.md` convention — a whole directory (references/…). */
-    dir: z9.boolean(),
+    dir: z11.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()
+    commit: z11.string().optional()
   }).optional()
 });
-var importableSkillSchema = z9.object({
-  name: z9.string(),
-  description: z9.string().optional()
+var importableSkillSchema = z11.object({
+  name: z11.string(),
+  description: z11.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(),
+var todoItemSchema = z11.object({
+  id: z11.string(),
+  ts: z11.string().optional(),
+  taskId: z11.string().optional(),
+  summary: z11.string().min(1),
+  action: z11.string().optional(),
+  prUrl: z11.string().optional(),
+  suggestedSkill: z11.string().optional(),
+  suggestedArgs: z11.string().optional(),
+  suggestedPrompt: z11.string().optional(),
   /** Explicit intent; missing infers from suggestedSkill/suggestedPrompt for old files. */
-  runnable: z9.boolean().optional(),
+  runnable: z11.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()
+  startedTaskId: z11.string().optional()
 });
-var removeTodoResponseSchema = z9.object({
-  removed: z9.literal(true)
+var removeTodoResponseSchema = z11.object({
+  removed: z11.literal(true)
 });
-var startTodoResponseSchema = z9.object({
+var startTodoResponseSchema = z11.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({
+import { z as z12 } from "zod";
+var agentConfigFormatSchema = z12.enum(["json", "jsonc", "toml", "markdown"]);
+var agentConfigScopeSchema = z12.enum(["user", "project", "local"]);
+var agentConfigKindSchema = z12.enum(["settings", "memory", "mcp"]);
+var agentConfigTrackedSchema = z12.enum(["tracked", "gitignored", "outside-repo"]);
+var agentConfigFileSchema = z12.object({
   /** Stable, opaque, URL-safe — the ONLY thing a client may name (traversal-proof). */
-  id: z10.string(),
+  id: z12.string(),
   /** Every runner that reads this file: `<repo>/AGENTS.md` is one file, two readers. */
-  runners: z10.array(runnerSchema),
+  runners: z12.array(runnerSchema),
   kind: agentConfigKindSchema,
   scope: agentConfigScopeSchema,
-  label: z10.string(),
-  path: z10.string(),
+  label: z12.string(),
+  path: z12.string(),
   format: agentConfigFormatSchema,
   tracked: agentConfigTrackedSchema,
-  seeded: z10.boolean(),
-  holdsMcp: z10.boolean(),
+  seeded: z12.boolean(),
+  holdsMcp: z12.boolean(),
   /** VERBATIM from the vendor docs. Never computed, never generic. */
-  precedence: z10.string(),
+  precedence: z12.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(),
+  hotReload: z12.string().optional(),
+  docsUrl: z12.string(),
+  exists: z12.boolean(),
+  size: z12.number(),
   /** sha256 of the bytes, or null when absent. */
-  version: z10.string().nullable(),
+  version: z12.string().nullable(),
   /** False in hosted mode (whole feature) — the client renders read-only up front. */
-  writable: z10.boolean(),
-  readOnlyReason: z10.string().optional()
+  writable: z12.boolean(),
+  readOnlyReason: z12.string().optional()
 });
-var userMcpListingSchema = z10.object({
-  path: z10.string(),
-  servers: z10.array(z10.string()),
-  readable: z10.boolean()
+var userMcpListingSchema = z12.object({
+  path: z12.string(),
+  servers: z12.array(z12.string()),
+  readable: z12.boolean()
 });
-var agentConfigListingSchema = z10.object({
-  editable: z10.boolean(),
-  files: z10.array(agentConfigFileSchema),
+var agentConfigListingSchema = z12.object({
+  editable: z12.boolean(),
+  files: z12.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(),
+var agentConfigFileContentSchema = z12.object({
+  id: z12.string(),
+  path: z12.string(),
+  exists: z12.boolean(),
+  content: z12.string(),
   /** sha256 of the bytes, or null when the file does not exist yet. */
-  version: z10.string().nullable()
+  version: z12.string().nullable()
 });
-var setAgentConfigInputSchema = z10.object({
-  content: z10.string().max(2e6),
-  version: z10.string().nullable()
+var setAgentConfigInputSchema = z12.object({
+  content: z12.string().max(2e6),
+  version: z12.string().nullable()
 });
 
 // ../contract/src/agent-profiles.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 var DEFAULT_AGENT_ACCOUNT_ID = "default";
-var agentAccountFileSchema = z11.object({
-  id: z11.string(),
+var agentAccountFileSchema = z13.object({
+  id: z13.string(),
   /** e.g. `settings.json` — the file's own name, since the folder is shown once on the account. */
-  label: z11.string(),
+  label: z13.string(),
   /** Absolute, resolved inside this account's config folder. */
-  path: z11.string(),
-  exists: z11.boolean()
+  path: z13.string(),
+  exists: z13.boolean()
 });
-var agentProfileSchema = z11.object({
+var agentProfileSchema = z13.object({
   /** `default` for the discovered profile, else the stored slug. */
-  id: z11.string(),
+  id: z13.string(),
   provider: providerIdSchema,
-  label: z11.string(),
+  label: z13.string(),
   /** As the user wrote it — a literal `~` is preserved, matching `browseRoot`/`projectsDir`. */
-  configDir: z11.string(),
+  configDir: z13.string(),
   /** Expanded absolute path. Same-origin route, like `ProjectListEntry.root`. */
-  path: z11.string(),
+  path: z13.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: z11.boolean(),
+  exists: z13.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: z11.boolean(),
+  looksValid: z13.boolean(),
   /** True for the profile xezar discovers from the environment. Never stored, never deletable. */
-  isDefault: z11.boolean(),
+  isDefault: z13.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
@@ -1626,35 +1728,35 @@ var agentProfileSchema = z11.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: z11.array(agentAccountFileSchema)
+  files: z13.array(agentAccountFileSchema)
 });
 function agentAccountRouteId(profile) {
   return profile.isDefault ? `default:${profile.provider}` : profile.id;
 }
-var agentAccountSelectionSchema = z11.object({
-  claude: z11.string().optional(),
-  codex: z11.string().optional(),
-  opencode: z11.string().optional(),
-  pi: z11.string().optional()
-});
-var agentProfilesResponseSchema = z11.object({
-  editable: z11.boolean(),
-  profiles: z11.array(agentProfileSchema),
+var agentAccountSelectionSchema = z13.object({
+  claude: z13.string().optional(),
+  codex: z13.string().optional(),
+  opencode: z13.string().optional(),
+  pi: z13.string().optional()
+});
+var agentProfilesResponseSchema = z13.object({
+  editable: z13.boolean(),
+  profiles: z13.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: z11.array(providerIdSchema),
+  profileCapableProviders: z13.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 (`~/.xezar/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 xezar version that never
    *  heard of accounts. Empty in hosted mode, where the whole family is withheld. */
-  selections: z11.record(z11.string(), agentAccountSelectionSchema),
+  selections: z13.record(z13.string(), agentAccountSelectionSchema),
   /** The machine-wide fallback account per provider, used by any repo that has chosen none. */
   defaults: agentAccountSelectionSchema
 });
-var selectAgentProfileInputSchema = z11.object({
+var selectAgentProfileInputSchema = z13.object({
   /**
    * Registry slug, or the reserved `default` boot alias. Resolved to a root server-side.
    *
@@ -1662,108 +1764,108 @@ var selectAgentProfileInputSchema = z11.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: z11.string().min(1).max(64).nullable(),
+  projectId: z13.string().min(1).max(64).nullable(),
   provider: providerIdSchema,
-  profileId: z11.string().max(64).nullable()
+  profileId: z13.string().max(64).nullable()
 });
-var agentProfileSelectionsResponseSchema = z11.object({
-  selections: z11.record(z11.string(), agentAccountSelectionSchema),
+var agentProfileSelectionsResponseSchema = z13.object({
+  selections: z13.record(z13.string(), agentAccountSelectionSchema),
   /** The machine-wide fallback, for repos with no selection of their own. */
   defaults: agentAccountSelectionSchema
 });
-var agentAccountStatusResponseSchema = z11.object({ status: providerStatusSchema });
-var agentAccountDetailsResponseSchema = z11.object({
-  available: z11.boolean(),
-  reason: z11.string().optional(),
-  fields: z11.array(z11.object({ label: z11.string(), value: z11.string() }))
+var agentAccountStatusResponseSchema = z13.object({ status: providerStatusSchema });
+var agentAccountDetailsResponseSchema = z13.object({
+  available: z13.boolean(),
+  reason: z13.string().optional(),
+  fields: z13.array(z13.object({ label: z13.string(), value: z13.string() }))
 });
-var openAgentAccountFileInputSchema = z11.object({
-  file: z11.string().min(1).max(200),
-  target: z11.string().min(1).max(64).optional()
+var openAgentAccountFileInputSchema = z13.object({
+  file: z13.string().min(1).max(200),
+  target: z13.string().min(1).max(64).optional()
 });
-var openAgentAccountFileResponseSchema = z11.object({
-  opened: z11.literal(true),
-  path: z11.string()
+var openAgentAccountFileResponseSchema = z13.object({
+  opened: z13.literal(true),
+  path: z13.string()
 });
-var createAgentProfileInputSchema = z11.object({
+var createAgentProfileInputSchema = z13.object({
   provider: providerIdSchema,
-  label: z11.string().trim().max(200).optional(),
+  label: z13.string().trim().max(200).optional(),
   /** Stored as written; validated absolute after `~` expansion, server-side. */
-  configDir: z11.string().trim().min(1).max(4096)
+  configDir: z13.string().trim().min(1).max(4096)
 });
-var agentProfileResponseSchema = z11.object({ profile: agentProfileSchema });
-var updateAgentProfileInputSchema = z11.object({
-  label: z11.string().trim().max(200).optional(),
-  configDir: z11.string().trim().min(1).max(4096).optional()
+var agentProfileResponseSchema = z13.object({ profile: agentProfileSchema });
+var updateAgentProfileInputSchema = z13.object({
+  label: z13.string().trim().max(200).optional(),
+  configDir: z13.string().trim().min(1).max(4096).optional()
 });
-var removeAgentProfileResponseSchema = z11.object({
-  removed: z11.literal(true),
-  id: z11.string()
+var removeAgentProfileResponseSchema = z13.object({
+  removed: z13.literal(true),
+  id: z13.string()
 });
 
 // ../contract/src/automations.ts
-import { z as z12 } from "zod";
-var automationEventSchema = z12.enum([
+import { z as z14 } from "zod";
+var automationEventSchema = z14.enum([
   "pull_request.opened",
   "issue.opened",
   "issue.labeled",
   "issue.unlabeled"
 ]);
-var automationFiltersSchema = z12.object({
-  authors: z12.array(z12.string()).optional(),
-  assignees: z12.array(z12.string()).optional(),
-  allLabels: z12.array(z12.string()).optional(),
-  anyLabels: z12.array(z12.string()).optional(),
-  excludeLabels: z12.array(z12.string()).optional(),
+var automationFiltersSchema = z14.object({
+  authors: z14.array(z14.string()).optional(),
+  assignees: z14.array(z14.string()).optional(),
+  allLabels: z14.array(z14.string()).optional(),
+  anyLabels: z14.array(z14.string()).optional(),
+  excludeLabels: z14.array(z14.string()).optional(),
   /** Required for the two label events — the server rejects a definition without it. */
-  changedLabels: z12.array(z12.string()).optional(),
-  lookbackDays: z12.number(),
-  maxRecords: z12.number()
+  changedLabels: z14.array(z14.string()).optional(),
+  lookbackDays: z14.number(),
+  maxRecords: z14.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: z12.string(),
-  variants: z12.union([z12.literal(1), z12.literal(2), z12.literal(3)]).optional(),
-  systemPrompt: z12.string().optional()
+  prompt: z14.string(),
+  variants: z14.union([z14.literal(1), z14.literal(2), z14.literal(3)]).optional(),
+  systemPrompt: z14.string().optional()
 });
-var automationDefinitionSchema = z12.object({
-  id: z12.string(),
+var automationDefinitionSchema = z14.object({
+  id: z14.string(),
   /** Bumped on every edit; a PUT must echo the revision it read (optimistic concurrency). */
-  revision: z12.number(),
-  name: z12.string(),
-  description: z12.string().optional(),
+  revision: z14.number(),
+  name: z14.string(),
+  description: z14.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: z12.boolean(),
-  events: z12.array(automationEventSchema),
-  intervalSeconds: z12.number(),
+  enabled: z14.boolean(),
+  events: z14.array(automationEventSchema),
+  intervalSeconds: z14.number(),
   filters: automationFiltersSchema,
   task: automationTaskSchema,
-  createdAt: z12.string(),
-  updatedAt: z12.string()
+  createdAt: z14.string(),
+  updatedAt: z14.string()
 });
-var automationCursorSchema = z12.object({
-  timestamp: z12.string(),
-  tieBreaker: z12.string().optional()
+var automationCursorSchema = z14.object({
+  timestamp: z14.string(),
+  tieBreaker: z14.string().optional()
 });
-var automationRuntimeStateSchema = z12.object({
+var automationRuntimeStateSchema = z14.object({
   /** The definition revision this state belongs to; a bumped revision re-baselines. */
-  revision: z12.number().optional(),
+  revision: z14.number().optional(),
   /** Enabling establishes a CURRENT-TIME baseline: records older than this never launch. */
-  baselineAt: z12.string().optional(),
+  baselineAt: z14.string().optional(),
   cursor: automationCursorSchema.optional(),
-  frozenHighWatermark: automationCursorSchema.extend({ tieBreaker: z12.string() }).optional(),
-  backlogAfter: automationCursorSchema.extend({ tieBreaker: z12.string() }).optional(),
-  nextCheckAt: z12.string().optional(),
-  lastSuccessAt: z12.string().optional(),
+  frozenHighWatermark: automationCursorSchema.extend({ tieBreaker: z14.string() }).optional(),
+  backlogAfter: automationCursorSchema.extend({ tieBreaker: z14.string() }).optional(),
+  nextCheckAt: z14.string().optional(),
+  lastSuccessAt: z14.string().optional(),
   /** Per-query GitHub ETags, so an unchanged page costs no rate-limit budget. */
-  etags: z12.record(z12.string(), z12.string()).optional(),
-  backoffUntil: z12.string().optional(),
-  consecutiveFailures: z12.number().optional()
+  etags: z14.record(z14.string(), z14.string()).optional(),
+  backoffUntil: z14.string().optional(),
+  consecutiveFailures: z14.number().optional()
 });
-var automationLogResultSchema = z12.enum([
+var automationLogResultSchema = z14.enum([
   "launched",
   "no-match",
   "duplicate",
@@ -1772,87 +1874,544 @@ var automationLogResultSchema = z12.enum([
   "baseline",
   "preview"
 ]);
-var automationLogRecordSchema = z12.object({
-  seq: z12.number(),
-  ts: z12.string(),
-  automationId: z12.string(),
-  revision: z12.number(),
+var automationLogRecordSchema = z14.object({
+  seq: z14.number(),
+  ts: z14.string(),
+  automationId: z14.string(),
+  revision: z14.number(),
   event: automationEventSchema.optional(),
   result: automationLogResultSchema,
-  reason: z12.string().optional(),
-  durationMs: z12.number().optional(),
-  receiptId: z12.string().optional(),
-  runId: z12.string().optional(),
-  githubNumber: z12.number().optional(),
-  githubTitle: z12.string().optional(),
-  githubUrl: z12.string().optional(),
-  rateLimit: z12.object({
-    bucket: z12.enum(["core", "search"]),
-    remaining: z12.number().optional(),
-    resetAt: z12.string().optional()
+  reason: z14.string().optional(),
+  durationMs: z14.number().optional(),
+  receiptId: z14.string().optional(),
+  runId: z14.string().optional(),
+  githubNumber: z14.number().optional(),
+  githubTitle: z14.string().optional(),
+  githubUrl: z14.string().optional(),
+  rateLimit: z14.object({
+    bucket: z14.enum(["core", "search"]),
+    remaining: z14.number().optional(),
+    resetAt: z14.string().optional()
   }).optional()
 });
-var automationCountsSchema = z12.object({
-  matches: z12.number(),
-  launched: z12.number(),
-  duplicates: z12.number(),
-  errors: z12.number()
+var automationCountsSchema = z14.object({
+  matches: z14.number(),
+  launched: z14.number(),
+  duplicates: z14.number(),
+  errors: z14.number()
 });
 var automationListEntrySchema = automationDefinitionSchema.extend({
   state: automationRuntimeStateSchema.optional(),
   latestLog: automationLogRecordSchema.optional(),
   counts: automationCountsSchema
 });
-var automationsResponseSchema = z12.object({
-  available: z12.boolean(),
-  reason: z12.string().optional(),
-  scheduler: z12.object({
-    state: z12.enum(["scheduled", "idle"]),
-    nextDue: z12.string().optional()
+var automationsResponseSchema = z14.object({
+  available: z14.boolean(),
+  reason: z14.string().optional(),
+  scheduler: z14.object({
+    state: z14.enum(["scheduled", "idle"]),
+    nextDue: z14.string().optional()
   }),
-  automations: z12.array(automationListEntrySchema)
+  automations: z14.array(automationListEntrySchema)
 });
-var automationResponseSchema = z12.object({ automation: automationDefinitionSchema });
-var automationDetailResponseSchema = z12.object({
+var automationResponseSchema = z14.object({ automation: automationDefinitionSchema });
+var automationDetailResponseSchema = z14.object({
   automation: automationDefinitionSchema,
   state: automationRuntimeStateSchema.optional(),
   latestLog: automationLogRecordSchema.optional()
 });
-var automationCheckSchema = z12.object({
-  id: z12.string(),
-  automationId: z12.string(),
-  mode: z12.enum(["preview", "execute"]),
-  status: z12.enum(["queued", "running", "complete", "error"]),
-  createdAt: z12.string(),
-  completedAt: z12.string().optional(),
-  matches: z12.number().optional(),
-  truncated: z12.boolean().optional(),
-  error: z12.string().optional()
-});
-var automationCheckQueuedResponseSchema = z12.object({ checkId: z12.string() });
-var automationLogResponseSchema = z12.object({
-  records: z12.array(automationLogRecordSchema)
-});
-var automationRetryResponseSchema = z12.object({
-  receiptId: z12.string(),
-  runId: z12.string()
-});
-var createAutomationInputSchema = automationDefinitionSchema.omit({ id: true, revision: true, createdAt: true, updatedAt: true, enabled: true }).extend({ enable: z12.boolean().optional() });
+var automationCheckSchema = z14.object({
+  id: z14.string(),
+  automationId: z14.string(),
+  mode: z14.enum(["preview", "execute"]),
+  status: z14.enum(["queued", "running", "complete", "error"]),
+  createdAt: z14.string(),
+  completedAt: z14.string().optional(),
+  matches: z14.number().optional(),
+  truncated: z14.boolean().optional(),
+  error: z14.string().optional()
+});
+var automationCheckQueuedResponseSchema = z14.object({ checkId: z14.string() });
+var automationLogResponseSchema = z14.object({
+  records: z14.array(automationLogRecordSchema)
+});
+var automationRetryResponseSchema = z14.object({
+  receiptId: z14.string(),
+  runId: z14.string()
+});
+var createAutomationInputSchema = automationDefinitionSchema.omit({ id: true, revision: true, createdAt: true, updatedAt: true, enabled: true }).extend({ enable: z14.boolean().optional() });
 var updateAutomationInputSchema = createAutomationInputSchema.omit({ enable: true }).extend({
-  enabled: z12.boolean().optional(),
-  expectedRevision: z12.number()
+  enabled: z14.boolean().optional(),
+  expectedRevision: z14.number()
+});
+var automationCheckInputSchema = z14.object({
+  mode: z14.enum(["preview", "execute"])
+});
+
+// ../contract/src/mcp-idempotency.ts
+import { z as z15 } from "zod";
+var operationIdSchema = z15.string().min(8).max(128).regex(/^[A-Za-z0-9_.:-]+$/);
+var operationOutcomeSchema = z15.enum(["ok", "rejected", "not-applied", "unverified"]);
+var operationResultRefSchema = z15.object({
+  kind: z15.string().min(1).max(64),
+  id: z15.string().min(1).max(256)
+});
+var operationReasonSchema = z15.string().min(1).max(64).regex(/^[a-z0-9_ -]+$/);
+var reconcilePredicateSchema = z15.discriminatedUnion("kind", [
+  /** The run id predicted from the operation key before the effect (D-06 § 12.1). */
+  z15.object({ kind: z15.literal("run-by-key"), predictedRunId: z15.uuid() }),
+  /** A forge list/search read, e.g. `gh pr list --head <branch>`. */
+  z15.object({
+    kind: z15.literal("forge-search"),
+    repository: z15.string().min(1),
+    headBranch: z15.string().min(1)
+  }),
+  /** The expected ref and the sha it should point at after the effect. */
+  z15.object({ kind: z15.literal("git-state"), ref: z15.string().min(1), sha: z15.string().min(1) }),
+  /** The action has no external effect to look for. */
+  z15.object({ kind: z15.literal("none") })
+]);
+var UNVERIFIED_GUIDANCE = "read current state; a new operationId is a new action";
+var operationSettledResultSchema = z15.object({
+  status: z15.enum(["ok", "rejected", "not-applied"]),
+  operationId: operationIdSchema,
+  action: z15.string().min(1),
+  /** `true` when this answer came from a stored receipt and no effect ran for this call. */
+  replayed: z15.boolean(),
+  /** Present on `ok` only. */
+  resultRef: operationResultRefSchema.optional(),
+  /** Present on `rejected` and `not-applied` only. */
+  errorCode: operationReasonSchema.optional()
+});
+var operationInProgressResultSchema = z15.object({
+  status: z15.literal("in-progress"),
+  operationId: operationIdSchema,
+  action: z15.string().min(1),
+  startedAt: z15.string()
+});
+var operationUnverifiedResultSchema = z15.object({
+  status: z15.literal("unverified"),
+  operationId: operationIdSchema,
+  action: z15.string().min(1),
+  startedAt: z15.string(),
+  reconcile: z15.object({
+    kind: z15.enum(["run-by-key", "forge-search", "git-state", "none"]),
+    attemptedAt: z15.string().optional(),
+    reason: operationReasonSchema
+  }),
+  guidance: z15.literal(UNVERIFIED_GUIDANCE)
+});
+var operationKeyConflictSchema = z15.object({
+  error: z15.literal("operation_key_conflict"),
+  operationId: operationIdSchema,
+  storedAction: z15.string().min(1),
+  storedAt: z15.string(),
+  mismatch: z15.enum(["action", "payload"])
+});
+var operationReceiptUnavailableSchema = z15.object({
+  error: z15.literal("operation_receipt_unavailable"),
+  operationId: operationIdSchema,
+  reason: z15.literal("journal_unwritable")
+});
+var operationAnswerSchema = z15.union([
+  operationSettledResultSchema,
+  operationInProgressResultSchema,
+  operationUnverifiedResultSchema,
+  operationKeyConflictSchema,
+  operationReceiptUnavailableSchema
+]);
+
+// ../contract/src/mcp-journal.ts
+import { z as z16 } from "zod";
+var MCP_JOURNAL_RETAINED_ROWS = 1e4;
+var MCP_JOURNAL_MIN_RETENTION_DAYS = 14;
+var MCP_JOURNAL_PAGE_ROWS = RUN_HISTORY_PAGE_ITEMS;
+var MCP_JOURNAL_PAGE_BYTES = 4e4;
+var MCP_JOURNAL_CURSOR_MAX_BYTES = 2048;
+var MCP_JOURNAL_SUMMARY_MAX_CHARS = 500;
+var mcpJournalCategorySchema = z16.enum(["E-01", "E-02", "E-03", "E-04", "E-05", "E-06"]);
+var mcpJournalOriginSchema = z16.enum(["human", "leader", "system"]);
+var mcpJournalOperationIdSchema = z16.string().min(8).max(128).regex(/^[A-Za-z0-9_.:-]+$/);
+var mcpJournalProjectIdSchema = z16.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+var mcpJournalSubjectSchema = z16.object({
+  type: z16.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
+  id: z16.string().min(1).max(256),
+  version: z16.string().min(1).max(512).nullable()
+});
+var mcpJournalSourceSchema = z16.object({
+  runId: z16.string().min(1).max(128),
+  runSeq: z16.number().int().nonnegative()
+});
+var mcpJournalKindSchema = z16.string().max(64).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/);
+var originFields = {
+  category: mcpJournalCategorySchema,
+  kind: mcpJournalKindSchema,
+  subject: mcpJournalSubjectSchema,
+  origin: mcpJournalOriginSchema,
+  causedBy: mcpJournalOperationIdSchema.nullable(),
+  summary: z16.string().min(1).max(MCP_JOURNAL_SUMMARY_MAX_CHARS),
+  source: mcpJournalSourceSchema.optional()
+};
+function leaderNamesItsOperation(value) {
+  return value.origin !== "leader" || value.causedBy !== null;
+}
+var LEADER_NEEDS_OPERATION = { message: "a leader row must name the operation that caused it", path: ["causedBy"] };
+var mcpJournalAppendInputSchema = z16.object(originFields).refine(leaderNamesItsOperation, LEADER_NEEDS_OPERATION);
+var mcpJournalRowSchema = z16.object({
+  eventId: z16.string().min(1),
+  journalSeq: z16.number().int().positive(),
+  ts: z16.string(),
+  projectId: mcpJournalProjectIdSchema,
+  ...originFields
+}).refine(leaderNamesItsOperation, LEADER_NEEDS_OPERATION);
+var mcpJournalCursorSchema = z16.string().min(1).max(MCP_JOURNAL_CURSOR_MAX_BYTES);
+var mcpJournalReadInputSchema = z16.object({
+  cursor: mcpJournalCursorSchema.optional(),
+  limit: z16.number().int().min(1).max(MCP_JOURNAL_PAGE_ROWS).optional()
+});
+var mcpJournalPageSchema = z16.object({
+  status: z16.literal("ok"),
+  events: z16.array(mcpJournalRowSchema),
+  /** Read after this next; equals the request's position when nothing was outstanding. */
+  nextCursor: mcpJournalCursorSchema,
+  /** More rows are already retained past `nextCursor` — read again, do not wait for an event. */
+  hasMore: z16.boolean(),
+  /** `null` while the journal is empty. */
+  oldestSeq: z16.number().int().positive().nullable(),
+  latestSeq: z16.number().int().nonnegative()
+});
+var mcpJournalCursorTooOldSchema = z16.object({
+  status: z16.literal("cursor_too_old"),
+  oldestSeq: z16.number().int().positive().nullable(),
+  latestSeq: z16.number().int().nonnegative(),
+  resumeCursor: mcpJournalCursorSchema,
+  recovery: z16.object({
+    required: z16.literal("current-state"),
+    message: z16.string()
+  })
 });
-var automationCheckInputSchema = z12.object({
-  mode: z12.enum(["preview", "execute"])
+var mcpJournalReadResultSchema = z16.discriminatedUnion("status", [
+  mcpJournalPageSchema,
+  mcpJournalCursorTooOldSchema
+]);
+var mcpJournalCursorRejectionSchema = z16.object({
+  error: z16.enum(["invalid_cursor", "cursor_project_mismatch"]),
+  message: z16.string()
 });
+
+// ../contract/src/mcp-event-catalog.ts
+import { z as z17 } from "zod";
+var MCP_EVENT_CATALOG = {
+  "E-01": "Task completion, failure, cancellation or blocking.",
+  "E-02": "A question requiring attention and a human answer to a question.",
+  "E-03": "Quality-gate result or a completed result ready for assessment.",
+  "E-04": "Human change to goal, acceptance criteria, instruction, plan or task state.",
+  "E-05": "Configuration/workflow change affecting execution.",
+  "E-06": "Executor availability change affecting execution."
+};
+var MCP_EVENT_KIND_CATEGORY = {
+  // E-01 — derived from a run STATUS transition (D-05 § 5.1: a terminal status is not an event type).
+  "task.done": "E-01",
+  "task.failed": "E-01",
+  "task.cancelled": "E-01",
+  /** The run parked at `waiting` with no structured question: it cannot go on without input. */
+  "task.blocked": "E-01",
+  // E-02
+  /** The agent raised a structured question (`ask.requested`) and parked at `waiting`. */
+  "question.asked": "E-02",
+  /** A human replied to a run that was waiting on one. */
+  "question.answered": "E-02",
+  // E-03 — F-11: the optional `review` status is a result ready for assessment, and is kept a
+  // DIFFERENT kind from a mandatory quality gate so neither can be mistaken for the other.
+  "gate.passed": "E-03",
+  "gate.failed": "E-03",
+  "result.ready": "E-03",
+  // E-04 — only ever with `origin: 'human'`.
+  "goal.changed": "E-04",
+  "instruction.added": "E-04",
+  "instruction.queued": "E-04",
+  "instruction.edited": "E-04",
+  "instruction.removed": "E-04",
+  // E-05
+  "config.changed": "E-05",
+  "workflow.saved": "E-05",
+  "workflow.deleted": "E-05",
+  "agent-config.changed": "E-05",
+  // E-06
+  "executor.available": "E-06",
+  "executor.unavailable": "E-06"
+};
+var mcpEventKindSchema = z17.enum(
+  Object.keys(MCP_EVENT_KIND_CATEGORY)
+);
+var MCP_EVENT_SUBJECT_TYPES = ["run", "config", "workflow", "agent-config", "executor"];
+var mcpEventSubjectTypeSchema = z17.enum(MCP_EVENT_SUBJECT_TYPES);
+var mcpCatalogEventSchema = mcpJournalRowSchema.superRefine((row, ctx) => {
+  const kind = mcpEventKindSchema.safeParse(row.kind);
+  if (!kind.success) {
+    ctx.addIssue({ code: "custom", path: ["kind"], message: `not a catalog kind: ${row.kind}` });
+    return;
+  }
+  if (MCP_EVENT_KIND_CATEGORY[kind.data] !== row.category) {
+    ctx.addIssue({ code: "custom", path: ["category"], message: `${row.kind} belongs to ${MCP_EVENT_KIND_CATEGORY[kind.data]}` });
+  }
+  if (!mcpEventSubjectTypeSchema.safeParse(row.subject.type).success) {
+    ctx.addIssue({ code: "custom", path: ["subject", "type"], message: `not a catalog subject: ${row.subject.type}` });
+  }
+  if (row.category === "E-04" && row.origin !== "human") {
+    ctx.addIssue({ code: "custom", path: ["origin"], message: "an E-04 row is a human change" });
+  }
+});
+
+// ../contract/src/mcp-audit.ts
+import { z as z18 } from "zod";
+var auditOriginSchema = z18.enum(["ui", "mcp", "automation", "cli"]);
+var auditOutcomeSchema = z18.enum(["ok", "rejected", "not-applied", "unverified"]);
+var AUDIT_ACTION_RE = /^[a-z][A-Za-z0-9-]*(\.[a-z][A-Za-z0-9-]*)+$/;
+var AUDIT_RESOURCE_KIND_RE = /^[a-z][a-z0-9-]*$/;
+var AUDIT_ID_RE = /^[A-Za-z0-9_.:-]+$/;
+var AUDIT_ERROR_CODE_RE = /^[a-z][a-z0-9_]*$/;
+var AUDIT_VERSION_TOKEN_RE = /^rev1:[a-z][a-z0-9-]*:[A-Za-z0-9_.-]{1,128}:(?:\d+|-):[0-9a-f]{12}$/;
+var auditResourceSchema = z18.object({
+  kind: z18.string().min(1).max(32).regex(AUDIT_RESOURCE_KIND_RE),
+  id: z18.string().min(1).max(128).regex(AUDIT_ID_RE)
+});
+var auditEntrySchema = z18.object({
+  /** Record format tag. A future incompatible shape is `v: 2`. */
+  v: z18.literal(1),
+  /** SHOULD — ISO 8601 time the operation settled. */
+  ts: z18.iso.datetime(),
+  /** MUST — the project the connection or cockpit scope is bound to. */
+  projectId: z18.string().min(1).max(128).regex(AUDIT_ID_RE),
+  /** SHOULD — the action id. */
+  action: z18.string().min(3).max(64).regex(AUDIT_ACTION_RE),
+  /** SHOULD — the resource acted on, when there is one. */
+  resource: auditResourceSchema.optional(),
+  /** SHOULD — the D-06 outcome. */
+  outcome: auditOutcomeSchema,
+  /** MUST be server-derived. Only `mcp` is written today — see `auditOriginSchema` above. */
+  origin: auditOriginSchema,
+  /**
+   * SHOULD — the wall-clock ms prefix of the D-02.3 fencing token (`<ms>-<UUIDv4>`) the mutation
+   * arrived under; absent for non-MCP origins. Never the whole token: that passes the fence.
+   */
+  ownerGeneration: z18.number().int().nonnegative().optional(),
+  /** SHOULD — `<projectId>/<operationId>` (D-06 § 5.2); absent for non-MCP origins. */
+  operationKey: z18.string().min(1).max(257).regex(/^[A-Za-z0-9_.:-]+\/[A-Za-z0-9_.:-]{8,128}$/).optional(),
+  /** SHOULD — the `expectedVersion` the caller sent, kept only when it has the `rev1` shape. */
+  versionToken: z18.string().max(200).regex(AUDIT_VERSION_TOKEN_RE).optional(),
+  /** SHOULD — SHA-256 (lowercase hex) of the canonical parsed payload (D-06 § 5.4). */
+  payloadDigest: z18.string().regex(/^[0-9a-f]{64}$/).optional(),
+  /** SHOULD — present when the outcome is not `ok`. */
+  errorCode: z18.string().min(1).max(64).regex(AUDIT_ERROR_CODE_RE).optional()
+});
+
+// ../contract/src/mcp-discovery.ts
+import { z as z19 } from "zod";
+var mcpDiscoveryActionIdSchema = z19.enum([
+  "create_task",
+  "parallel_variants",
+  "worktree_choice",
+  "model_selection",
+  "github",
+  "automations",
+  "inbox",
+  "open_in_app",
+  "agent_config_write",
+  "workspace_limits"
+]);
+var mcpDiscoveryActionSchema = z19.discriminatedUnion("status", [
+  z19.strictObject({ id: mcpDiscoveryActionIdSchema, label: z19.string(), status: z19.literal("available") }),
+  z19.strictObject({
+    id: mcpDiscoveryActionIdSchema,
+    label: z19.string(),
+    status: z19.literal("unavailable"),
+    reason: z19.string().min(1)
+  }),
+  z19.strictObject({
+    id: mcpDiscoveryActionIdSchema,
+    label: z19.string(),
+    status: z19.literal("read-only"),
+    reason: z19.string().min(1)
+  })
+]);
+var mcpDiscoveryAgentSchema = z19.strictObject({
+  runner: runnerSchema,
+  installed: z19.boolean(),
+  version: z19.string().optional(),
+  enabled: z19.boolean(),
+  signIn: providerConnectionStateSchema,
+  usable: z19.boolean(),
+  reason: z19.string().optional()
+});
+var mcpDiscoveryToolCheckSchema = z19.strictObject({
+  name: z19.enum(["gh", "git"]),
+  available: z19.boolean(),
+  reason: z19.string().optional()
+});
+var mcpDiscoveryLimitsSchema = z19.strictObject({
+  maxParallel: z19.strictObject({ effective: z19.number(), project: z19.number().nullable(), workspace: z19.number() }),
+  memoryLimitMb: z19.strictObject({
+    effective: z19.number().nullable(),
+    project: z19.number().nullable(),
+    workspace: z19.number().nullable()
+  }),
+  maxMonitoringSessions: z19.number(),
+  /** `null` means a parked session stays parked. */
+  monitoringWakeIntervalMinutes: z19.number().nullable(),
+  autoResumeOnUsageLimit: z19.boolean(),
+  /** `null` means an idle session is never closed. */
+  idleTimeoutMinutes: z19.number().nullable(),
+  /** This project's count of finished worktrees kept on disk; 0 keeps all. */
+  worktreeRetention: z19.number()
+});
+var mcpDiscoverySchema = z19.strictObject({
+  project: z19.strictObject({
+    id: z19.string(),
+    name: z19.string(),
+    /** The bound project's own root; trimmed to its basename in hosted mode, like `/health`. */
+    root: z19.string()
+  }),
+  xezarVersion: z19.string(),
+  repository: z19.strictObject({ git: z19.boolean(), branch: z19.string().optional() }),
+  settings: z19.strictObject({
+    defaultRunner: runnerSchema,
+    baseBranch: z19.string().nullable(),
+    modelsLocked: z19.boolean()
+  }),
+  capabilities: capabilitiesSchema.pick({ localHandoff: true, followups: true, automations: true }).strict(),
+  agents: z19.array(mcpDiscoveryAgentSchema),
+  tools: z19.array(mcpDiscoveryToolCheckSchema),
+  limits: mcpDiscoveryLimitsSchema,
+  actions: z19.array(mcpDiscoveryActionSchema)
+});
+
+// ../contract/src/mcp-api-reference.ts
+import { z as z20 } from "zod";
+var mcpToolAnnotationsSchema = z20.strictObject({
+  readOnlyHint: z20.boolean().optional(),
+  destructiveHint: z20.boolean().optional(),
+  idempotentHint: z20.boolean().optional(),
+  openWorldHint: z20.boolean().optional()
+});
+var mcpToolListingSchema = z20.strictObject({
+  name: z20.string(),
+  title: z20.string().optional(),
+  description: z20.string(),
+  inputSchema: z20.record(z20.string(), z20.unknown()),
+  annotations: mcpToolAnnotationsSchema.optional()
+});
+var mcpRefusedActionSchema = z20.object({
+  tool: z20.string(),
+  action: z20.string(),
+  boundary: z20.string(),
+  reason: z20.string()
+});
+var mcpRefusedArgumentSchema = z20.object({
+  tool: z20.string(),
+  argument: z20.string(),
+  reason: z20.string()
+});
+var mcpGuardSchema = z20.object({
+  tool: z20.string(),
+  argument: z20.string(),
+  everyCall: z20.boolean(),
+  requiredBy: z20.array(z20.string())
+});
+var mcpNotExposedSchema = z20.object({
+  what: z20.string(),
+  detail: z20.string(),
+  forbiddenBy: z20.array(z20.string())
+});
+var mcpApiReferenceAvailableSchema = z20.object({
+  available: z20.literal(true),
+  xezarVersion: z20.string(),
+  /** Newest first — the revisions the bridge negotiates. */
+  protocolVersions: z20.array(z20.string()),
+  capabilities: z20.object({ tools: z20.object({ listChanged: z20.boolean() }) }),
+  /** Exactly `tools/list`: `[HEALTH_TOOL, ...tools.map(toolListing)]`, in that order. */
+  tools: z20.array(mcpToolListingSchema),
+  refusedActions: z20.array(mcpRefusedActionSchema),
+  refusedArguments: z20.array(mcpRefusedArgumentSchema),
+  /** One entry per tool and guard the tool's schema lists. */
+  guards: z20.array(mcpGuardSchema),
+  notExposed: z20.array(mcpNotExposedSchema)
+});
+var mcpApiReferenceSchema = z20.discriminatedUnion("available", [
+  mcpApiReferenceAvailableSchema,
+  z20.object({ available: z20.literal(false), reason: z20.string() })
+]);
+
+// ../contract/src/mcp-leader.ts
+import { z as z21 } from "zod";
+var mcpLeaderAttachInputSchema = z21.discriminatedUnion("client", [
+  z21.strictObject({
+    action: z21.literal("attach"),
+    client: z21.literal("opencode"),
+    baseUrl: z21.url({ protocol: /^https?$/ }).max(500),
+    sessionId: z21.string().trim().min(1).max(200)
+  }),
+  z21.strictObject({ action: z21.literal("attach"), client: z21.literal("pi") })
+]);
+var mcpLeaderActionInputSchema = z21.union([
+  mcpLeaderAttachInputSchema,
+  z21.strictObject({ action: z21.literal("stop") })
+]);
+var mcpLeaderSessionSchema = z21.object({
+  client: z21.enum(["opencode", "pi"]),
+  state: z21.literal("attached")
+});
+var mcpLeaderDeliverySchema = z21.object({
+  state: z21.enum(["inert", "idle", "dispatching", "recovering", "disconnected", "ended"]),
+  deliveredSeq: z21.number().int().nonnegative(),
+  ackedSeq: z21.number().int().nonnegative(),
+  reactedSeq: z21.number().int().nonnegative(),
+  latestSeq: z21.number().int().nonnegative()
+});
+var mcpLeaderBlockerSchema = z21.object({
+  code: z21.string(),
+  message: z21.string(),
+  fix: z21.string()
+});
+var mcpLeaderStatusSchema = z21.discriminatedUnion("available", [
+  z21.object({ available: z21.literal(false), reason: z21.string() }),
+  z21.object({
+    available: z21.literal(true),
+    leader: mcpLeaderSessionSchema.nullable(),
+    delivery: mcpLeaderDeliverySchema.nullable(),
+    blocker: mcpLeaderBlockerSchema.nullable()
+  })
+]);
 export {
+  AUDIT_ACTION_RE,
+  AUDIT_ERROR_CODE_RE,
+  AUDIT_ID_RE,
+  AUDIT_RESOURCE_KIND_RE,
+  AUDIT_VERSION_TOKEN_RE,
   DEFAULT_AGENT_ACCOUNT_ID,
   FILE_ATTACHMENT_MEDIA_TYPES,
+  MCP_EVENT_CATALOG,
+  MCP_EVENT_KIND_CATEGORY,
+  MCP_EVENT_SUBJECT_TYPES,
+  MCP_EXECUTION_FAILED_GUIDANCE,
+  MCP_JOURNAL_CURSOR_MAX_BYTES,
+  MCP_JOURNAL_MIN_RETENTION_DAYS,
+  MCP_JOURNAL_PAGE_BYTES,
+  MCP_JOURNAL_PAGE_ROWS,
+  MCP_JOURNAL_RETAINED_ROWS,
+  MCP_JOURNAL_SUMMARY_MAX_CHARS,
+  MCP_PROJECT_OCCUPIED_CODE,
+  MCP_PROJECT_OCCUPIED_REASON,
+  MCP_SESSION_EXPIRED_CODE,
+  MCP_SESSION_EXPIRED_REASON,
+  MCP_STALE_VERSION_GUIDANCE,
+  MCP_VERSION_TOKEN_TAG,
   MODEL_DISCOVERY_RUNNERS,
   PROJECT_TAGS_MAX,
   PROJECT_TAG_MAX_LENGTH,
   REFERENCE_STATUS_MAX,
   RUN_HISTORY_PAGE_ITEMS,
+  UNVERIFIED_GUIDANCE,
   agentAccountDetailsResponseSchema,
   agentAccountFileSchema,
   agentAccountRouteId,
@@ -1871,8 +2430,13 @@ export {
   agentProfilesResponseSchema,
   apiRunSchema,
   archiveFinishedResponseSchema,
+  archiveRunInputSchema,
   attachmentExtension,
   attachmentInputSchema,
+  auditEntrySchema,
+  auditOriginSchema,
+  auditOutcomeSchema,
+  auditResourceSchema,
   automationCheckInputSchema,
   automationCheckQueuedResponseSchema,
   automationCheckSchema,
@@ -1901,6 +2465,7 @@ export {
   checkoutProjectInputSchema,
   configResponseSchema,
   continueResponseSchema,
+  continueRunInputSchema,
   createAgentProfileInputSchema,
   createAutomationInputSchema,
   createPrResponseSchema,
@@ -1911,10 +2476,12 @@ export {
   deleteWorkflowResponseSchema,
   diffStatSchema,
   editQueuedMessageResponseSchema,
+  executionFailedSchema,
   finishResponseSchema,
   forgeInfoSchema,
   fsBrowseDirSchema,
   fsBrowseResponseSchema,
+  gitCommitInputSchema,
   gitCommitResponseSchema,
   gitPushResponseSchema,
   githubChecksDataSchema,
@@ -1929,6 +2496,8 @@ export {
   githubPrCheckSchema,
   githubPrMergeStateResponseSchema,
   githubPrMergeStateSchema,
+  githubPrReadyInputSchema,
+  githubPrReadyResponseSchema,
   githubRefStatusDataSchema,
   githubSearchDataSchema,
   githubTimelineEventKindSchema,
@@ -1944,6 +2513,49 @@ export {
   launchKeyResponseSchema,
   logEntrySchema,
   markAllReadResponseSchema,
+  mcpApiReferenceAvailableSchema,
+  mcpApiReferenceSchema,
+  mcpCatalogEventSchema,
+  mcpDiscoveryActionIdSchema,
+  mcpDiscoveryActionSchema,
+  mcpDiscoveryAgentSchema,
+  mcpDiscoveryLimitsSchema,
+  mcpDiscoverySchema,
+  mcpDiscoveryToolCheckSchema,
+  mcpEventKindSchema,
+  mcpEventSubjectTypeSchema,
+  mcpExpectedVersionSchema,
+  mcpGuardSchema,
+  mcpJournalAppendInputSchema,
+  mcpJournalCategorySchema,
+  mcpJournalCursorRejectionSchema,
+  mcpJournalCursorSchema,
+  mcpJournalCursorTooOldSchema,
+  mcpJournalKindSchema,
+  mcpJournalOperationIdSchema,
+  mcpJournalOriginSchema,
+  mcpJournalPageSchema,
+  mcpJournalProjectIdSchema,
+  mcpJournalReadInputSchema,
+  mcpJournalReadResultSchema,
+  mcpJournalRowSchema,
+  mcpJournalSourceSchema,
+  mcpJournalSubjectSchema,
+  mcpLeaderActionInputSchema,
+  mcpLeaderBlockerSchema,
+  mcpLeaderDeliverySchema,
+  mcpLeaderSessionSchema,
+  mcpLeaderStatusSchema,
+  mcpNotExposedSchema,
+  mcpProjectOccupiedErrorSchema,
+  mcpRefusedActionSchema,
+  mcpRefusedArgumentSchema,
+  mcpSessionExpiredErrorSchema,
+  mcpToolAnnotationsSchema,
+  mcpToolListingSchema,
+  mcpVersionTokenSchema,
+  mcpVersionedResourceKindSchema,
+  mcpVersionedResourceRefSchema,
   messageInputSchema,
   messageResponseSchema,
   modelDiscoveryRunnerSchema,
@@ -1954,20 +2566,35 @@ export {
   openProjectInSchema,
   openTargetSchema,
   openTargetsResponseSchema,
+  operationAnswerSchema,
+  operationIdSchema,
+  operationInProgressResultSchema,
+  operationKeyConflictSchema,
+  operationOutcomeSchema,
+  operationReasonSchema,
+  operationReceiptUnavailableSchema,
+  operationResultRefSchema,
+  operationSettledResultSchema,
+  operationUnverifiedResultSchema,
   parsedWorkflowSchema,
   patchRunInputSchema,
+  pickVariantInputSchema,
   pickVariantResponseSchema,
+  pinRunInputSchema,
   planResponseSchema,
   processUsageSchema,
   projectListEntrySchema,
+  projectOwnerStateSchema,
   projectsResponseSchema,
   providerConnectResponseSchema,
   providerConnectionStateSchema,
   providerIdSchema,
   providerStatusResponseSchema,
   providerStatusSchema,
+  queuedMessagePatchInputSchema,
   queuedMessageSchema,
   reclaimWorktreesResponseSchema,
+  reconcilePredicateSchema,
   referenceStatusSchema,
   referenceStatusesByProjectSchema,
   registerProjectResponseSchema,
@@ -1994,6 +2621,8 @@ export {
   runIndexEntrySchema,
   runRecordSchema,
   runStatusSchema,
+  runVersionGuardInputSchema,
+  runVersionResponseSchema,
   runnerDiscoversModels,
   runnerModelCatalogResponseSchema,
   runnerModelOptionSchema,
@@ -2012,6 +2641,7 @@ export {
   skillsUpdateScopeStateSchema,
   skillsUpdateStateSchema,
   skillsUpdateStatusSchema,
+  staleVersionRejectionSchema,
   startTodoResponseSchema,
   statusEntrySchema,
   stepStateSchema,
@@ -2023,6 +2653,8 @@ export {
   updateProjectInputSchema,
   updateProjectResponseSchema,
   userMcpListingSchema,
+  versionedMutationDoneSchema,
+  versionedMutationOutcomeSchema,
   workflowDefSchema,
   workflowLoadIssueSchema,
   workflowStepDefSchema,