@open-mercato/cezar 0.9.3 → 0.10.0-pr892.1298

package/dist/contract/index.js

@@ -6,6 +6,37 @@ var runEventSchema = z.looseObject({
   stepId: z.string().optional(),
   type: z.string()
 });
+var RUN_HISTORY_PAGE_ITEMS = 100;
+var runIdParamSchema = z.object({
+  id: z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/)
+});
+var runHistoryCursorSchema = z.string().min(1).max(2048);
+var runHistoryQuerySchema = z.object({
+  cursor: runHistoryCursorSchema.optional()
+});
+var runEventsQuerySchema = z.object({
+  cursor: runHistoryCursorSchema.optional(),
+  afterSeq: z.coerce.number().int().nonnegative().optional()
+});
+var runHistoryEventSchema = z.object({
+  seq: z.number(),
+  ts: z.string(),
+  stepId: z.string().optional(),
+  type: z.string()
+}).catchall(z.any());
+var runHistoryPageSchema = z.object({
+  events: z.array(runHistoryEventSchema),
+  itemCount: z.number().int().min(0).max(RUN_HISTORY_PAGE_ITEMS),
+  olderCursor: runHistoryCursorSchema.optional(),
+  newerCursor: runHistoryCursorSchema.optional(),
+  liveCursor: runHistoryCursorSchema,
+  asOfSeq: z.number().int().nonnegative(),
+  hasOlder: z.boolean()
+});
+var runHistoryContextSchema = z.object({
+  contextEvents: z.array(runHistoryEventSchema),
+  asOfSeq: z.number().int().nonnegative()
+});
 var checkoutProgressEventSchema = z.object({
   checkoutId: z.string().optional(),
   name: z.string(),
@@ -16,14 +47,14 @@ var checkoutProgressEventSchema = z.object({
 
 // ../contract/src/health.ts
 import { z as z2 } from "zod";
-var runnerSchema = z2.enum(["claude", "codex", "opencode"]);
+var runnerSchema = z2.enum(["claude", "codex", "opencode", "pi"]);
 var repoInfoSchema = z2.object({
   root: z2.string(),
   branch: z2.string(),
   remote: z2.string().optional()
 });
 var backendCheckSchema = z2.object({
-  name: z2.enum(["claude", "codex", "opencode", "gh", "git"]),
+  name: z2.enum(["claude", "codex", "opencode", "pi", "gh", "git"]),
   available: z2.boolean(),
   version: z2.string().optional(),
   hint: z2.string().optional()
@@ -88,78 +119,268 @@ var healthResponseSchema = z2.object({
 });
 
 // ../contract/src/runs.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
-// ../contract/src/workflows.ts
+// ../contract/src/github.ts
 import { z as z3 } from "zod";
-var workflowStepDefSchema = z3.object({
-  id: z3.string().min(1),
-  name: z3.string().optional(),
+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(),
+  /** PRs only. */
+  isDraft: z3.boolean().optional(),
+  additions: z3.number().optional(),
+  deletions: z3.number().optional(),
+  checks: checksGlyphSchema.optional()
+});
+var githubDataSchema = z3.object({
+  available: z3.boolean(),
+  /** Why it is unavailable (`gh` missing, no remote, offline…). Never an error — a hint. */
+  reason: z3.string().optional(),
+  /** owner/name, when known. */
+  repo: z3.string().optional(),
+  syncedAt: z3.string().optional(),
+  issues: z3.array(githubItemSchema),
+  prs: z3.array(githubItemSchema),
+  /** Repo-wide label name → 6-hex color (no `#`); lets chips tint like GitHub. Additive. */
+  labelColors: z3.record(z3.string(), z3.string()).optional()
+});
+var githubChecksDataSchema = z3.discriminatedUnion("available", [
+  z3.object({
+    available: z3.literal(true),
+    checks: z3.record(z3.number(), checksGlyphSchema)
+  }),
+  z3.object({
+    available: z3.literal(false),
+    reason: z3.string()
+  })
+]);
+var referenceStatusSchema = z3.enum([
+  "draft",
+  "review-required",
+  "changes-requested",
+  "checks-pending",
+  "checks-failing",
+  "ready",
+  "merged",
+  "closed",
+  "open",
+  "completed",
+  "not-planned"
+]);
+var recheckAfterMsSchema = z3.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),
+    recheckAfterMs: recheckAfterMsSchema
+  }),
+  z3.object({
+    available: z3.literal(false),
+    reason: z3.string(),
+    recheckAfterMs: recheckAfterMsSchema
+  })
+]);
+var githubCommentSchema = z3.object({
+  id: z3.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"]),
+  /** Reviews only — drives the state chip. */
+  reviewState: z3.enum(["approved", "changes_requested", "commented", "dismissed"]).optional(),
+  url: z3.string()
+});
+var githubTimelineEventKindSchema = z3.enum([
+  "committed",
+  "labeled",
+  "unlabeled",
+  "assigned",
+  "unassigned",
+  "merged",
+  "closed",
+  "reopened",
+  "head_ref_force_pushed",
+  "cross-referenced",
+  "renamed"
+]);
+var githubTimelineEventSchema = z3.object({
+  id: z3.string(),
+  kind: githubTimelineEventKindSchema,
+  /** Login — or the git author name for `committed`, which carries no GitHub actor. */
+  actor: z3.string(),
+  /** Absent for `committed`. */
+  avatarUrl: z3.string().optional(),
+  createdAt: z3.string(),
+  url: z3.string().optional(),
+  /** `committed` — full 40-char SHA. */
+  sha: z3.string().optional(),
+  /** `committed` — first line, capped at 120 chars. */
+  message: z3.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(),
+  /** `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(),
+  /** Chronological, oldest first. */
+  comments: z3.array(githubCommentSchema),
+  /** True when either stream hit its cap, or the timeline fetch stopped short. */
+  truncated: z3.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),
+  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() })
+]);
+var githubMergeResponseSchema = z3.object({
+  merged: z3.literal(true),
+  number: z3.number(),
+  url: z3.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(),
+    /** Present when the payload is complete but partial in some other way (a capped patch). */
+    reason: z3.string().optional()
+  }),
+  z3.object({ available: z3.literal(false), reason: z3.string() })
+]);
+
+// ../contract/src/workflows.ts
+import { z as z4 } from "zod";
+var workflowStepDefSchema = z4.object({
+  id: z4.string().min(1),
+  name: z4.string().optional(),
   // agent step
-  prompt: z3.string().optional(),
-  skill: z3.string().optional(),
-  model: z3.string().optional(),
+  prompt: z4.string().optional(),
+  skill: z4.string().optional(),
+  model: z4.string().optional(),
   /** Per-step agent backend override (falls back to the task / config default). */
   runner: runnerSchema.optional(),
-  allowedTools: z3.array(z3.string()).optional(),
-  bashAllowlist: z3.array(z3.string()).optional(),
+  allowedTools: z4.array(z4.string()).optional(),
+  bashAllowlist: z4.array(z4.string()).optional(),
   // check step
-  command: z3.string().optional(),
-  onFail: z3.object({
-    retry: z3.string().min(1),
-    max: z3.number().int().positive().default(2)
+  command: z4.string().optional(),
+  onFail: z4.object({
+    retry: z4.string().min(1),
+    max: z4.number().int().positive().default(2)
   }).optional()
 }).refine((s) => Boolean(s.command) !== Boolean(s.prompt ?? s.skill), {
   message: "a step is either an agent step (prompt/skill) or a check step (command), not both"
 });
-var workflowDefSchema = z3.object({
-  name: z3.string(),
-  description: z3.string().optional(),
-  steps: z3.array(workflowStepDefSchema),
-  source: z3.enum(["built-in", "file"]),
+var workflowDefSchema = z4.object({
+  name: z4.string(),
+  description: z4.string().optional(),
+  steps: z4.array(workflowStepDefSchema),
+  source: z4.enum(["built-in", "file"]),
   /** Absent on built-ins — which is exactly what makes them undeletable. */
-  path: z3.string().optional()
+  path: z4.string().optional()
 });
-var workflowLoadIssueSchema = z3.object({
-  path: z3.string(),
-  message: z3.string()
-});
-var workflowsResponseSchema = z3.object({
-  workflows: z3.array(workflowDefSchema),
-  issues: z3.array(workflowLoadIssueSchema)
-});
-var saveWorkflowInputSchema = z3.object({
-  name: z3.string().trim().min(1).max(80),
-  description: z3.string().max(2e3, "must be at most 2000 characters").optional(),
-  steps: z3.array(workflowStepDefSchema).min(1).max(8).optional(),
-  skills: z3.array(z3.string().trim().min(1)).min(1).max(8).optional(),
-  overwrite: z3.boolean().optional()
+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()
 }).refine((b) => Boolean(b.steps) !== Boolean(b.skills), {
   message: 'provide either "steps" or "skills", not both'
 });
-var saveWorkflowResponseSchema = z3.object({
-  path: z3.string(),
-  name: z3.string()
+var saveWorkflowResponseSchema = z4.object({
+  path: z4.string(),
+  name: z4.string()
 });
-var parsedWorkflowSchema = z3.object({
-  name: z3.string(),
-  description: z3.string().optional(),
-  steps: z3.array(workflowStepDefSchema)
+var parsedWorkflowSchema = z4.object({
+  name: z4.string(),
+  description: z4.string().optional(),
+  steps: z4.array(workflowStepDefSchema)
 });
-var deleteWorkflowResponseSchema = z3.object({
-  ok: z3.literal(true),
-  path: z3.string()
+var deleteWorkflowResponseSchema = z4.object({
+  ok: z4.literal(true),
+  path: z4.string()
 });
-var planResponseSchema = z3.object({
+var planResponseSchema = z4.object({
   /** The kebab-case workflow title the planner proposed. Absent on the degraded fallback. */
-  name: z3.string().optional(),
-  steps: z3.array(workflowStepDefSchema),
-  rationale: z3.string(),
-  fallback: z3.boolean()
+  name: z4.string().optional(),
+  steps: z4.array(workflowStepDefSchema),
+  rationale: z4.string(),
+  fallback: z4.boolean()
 });
 
 // ../contract/src/runs.ts
-var runStatusSchema = z4.enum([
+var runStatusSchema = z5.enum([
   "queued",
   "running",
   "waiting",
@@ -168,8 +389,8 @@ var runStatusSchema = z4.enum([
   "failed",
   "cancelled"
 ]);
-var runActivitySchema = z4.enum(["monitoring"]);
-var stepStatusSchema = z4.enum([
+var runActivitySchema = z5.enum(["monitoring"]);
+var stepStatusSchema = z5.enum([
   "pending",
   "running",
   "waiting",
@@ -179,14 +400,14 @@ var stepStatusSchema = z4.enum([
   "cancelled",
   "skipped"
 ]);
-var usageCounterSchema = z4.number().finite().nonnegative();
-var stepStateSchema = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  kind: z4.enum(["agent", "check"]),
+var usageCounterSchema = z5.number().finite().nonnegative();
+var stepStateSchema = z5.object({
+  id: z5.string(),
+  name: z5.string(),
+  kind: z5.enum(["agent", "check"]),
   status: stepStatusSchema,
-  iterations: z4.number(),
-  tokensUsed: z4.number(),
+  iterations: z5.number(),
+  tokensUsed: z5.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
   usageInvocationsStarted: usageCounterSchema.optional(),
@@ -194,66 +415,74 @@ var stepStateSchema = z4.object({
   usageTurnsStarted: usageCounterSchema.optional(),
   usageTurnsRecorded: usageCounterSchema.optional(),
   usageInvocationEpoch: usageCounterSchema.optional(),
-  startedAt: z4.string().optional(),
-  finishedAt: z4.string().optional(),
-  error: z4.string().optional(),
+  startedAt: z5.string().optional(),
+  finishedAt: z5.string().optional(),
+  error: z5.string().optional(),
   /** Latest agent session id — `claude --resume <id>` and friends. */
-  sessionId: z4.string().optional(),
+  sessionId: z5.string().optional(),
   /** Backend that owns `sessionId`; absent on records written before backend affinity. */
   backend: runnerSchema.optional(),
-  costUsd: z4.number().optional()
-});
-var diffStatSchema = z4.object({
-  adds: z4.number(),
-  dels: z4.number(),
-  files: z4.number(),
+  /** 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()
+});
+var diffStatSchema = z5.object({
+  adds: z5.number(),
+  dels: z5.number(),
+  files: z5.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: z4.boolean().optional()
+  repointed: z5.boolean().optional()
 });
-var queuedMessageSchema = z4.object({
-  id: z4.string(),
-  text: z4.string(),
+var queuedMessageSchema = z5.object({
+  id: z5.string(),
+  text: z5.string(),
   /** `/api/v1/runs/:id/images/…` URLs — attachments are persisted, never inlined. */
-  images: z4.array(z4.string()).optional(),
-  createdAt: z4.string()
+  images: z5.array(z5.string()).optional(),
+  createdAt: z5.string()
 });
-var processUsageSchema = z4.object({
+var processUsageSchema = z5.object({
   /** Sum of `%cpu` across the tree — can exceed 100 on multi-core work. */
-  cpuPct: z4.number(),
-  rssBytes: z4.number(),
-  procCount: z4.number()
+  cpuPct: z5.number(),
+  rssBytes: z5.number(),
+  procCount: z5.number()
 });
-var runRecordSchema = z4.object({
-  id: z4.string(),
-  title: z4.string(),
+var runRecordSchema = z5.object({
+  id: z5.string(),
+  title: z5.string(),
   /** Display title (#389): auto-derived from the first agent turn, or the user's inline edit
    *  (`PATCH /runs/:id` sets it together with `title`). Show `titleSummary ?? title`. */
-  titleSummary: z4.string().optional(),
+  titleSummary: z5.string().optional(),
   /** Refreshed on every turn-end; absent until the first turn ends (and on worktree-less runs). */
   diffStat: diffStatSchema.optional(),
-  workflow: z4.string(),
-  task: z4.string(),
+  workflow: z5.string(),
+  task: z5.string(),
   /** Prompt messages stacked onto the run while it waited for a free agent slot (#472). Folded
    *  into the prompt at dequeue — never delivered as their own turns. Absent on pre-#472 runs. */
-  queuedMessages: z4.array(queuedMessageSchema).optional(),
+  queuedMessages: z5.array(queuedMessageSchema).optional(),
   /** URLs of images attached to the initial task prompt (#image-display). */
-  taskImages: z4.array(z4.string()).optional(),
-  model: z4.string().optional(),
+  taskImages: z5.array(z5.string()).optional(),
+  model: z5.string().optional(),
   /** Normalized provider/model identity used for attribution and reproducible replay. */
-  modelIdentity: z4.string().optional(),
+  modelIdentity: z5.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(),
   /** Echo of the extra system prompt the run used (POST override or config default). */
-  systemPrompt: z4.string().optional(),
+  systemPrompt: z5.string().optional(),
   /** false when the run deliberately disabled follow-up todo generation. Absent means enabled. */
-  generateFollowups: z4.boolean().optional(),
+  generateFollowups: z5.boolean().optional(),
   /** Autonomous mode (#autonomous): the run never parks at `waiting` or the terminal `review`
    *  gate. Absent = falsy = not autonomous. */
-  autonomous: z4.boolean().optional(),
+  autonomous: z5.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
@@ -263,76 +492,83 @@ var runRecordSchema = z4.object({
    * launching definition matched, recorded on the run for the audit trail, and `src/runs/store.ts`
    * persists it as free text so an older cezar can still read a record written by a newer one.
    */
-  automation: z4.object({
-    automationId: z4.string(),
-    automationRevision: z4.number(),
-    receiptId: z4.string(),
-    event: z4.string(),
-    githubUrl: z4.string()
+  automation: z5.object({
+    automationId: z5.string(),
+    automationRevision: z5.number(),
+    receiptId: z5.string(),
+    event: z5.string(),
+    githubUrl: z5.string()
   }).optional(),
   status: runStatusSchema,
   /** `monitoring` while `status === 'running'` and the agent is working on downstream work.
    *  Absent on old runs; cleared on resume/end. */
   activity: runActivitySchema.optional(),
   /** Exact ISO-8601 deadline for the next automatic monitoring check. */
-  monitoringWakeAt: z4.string().optional(),
+  monitoringWakeAt: z5.string().optional(),
   /** The current live monitoring epoch exhausted its 40 automatic checks. */
-  monitoringWakeCapReached: z4.boolean().optional(),
-  createdAt: z4.string(),
-  startedAt: z4.string().optional(),
-  finishedAt: z4.string().optional(),
-  tokensUsed: z4.number(),
+  monitoringWakeCapReached: z5.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(),
+  /** 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(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
-  costUsd: z4.number().optional(),
-  pullRequestUrl: z4.string().optional(),
+  costUsd: z5.number().optional(),
+  pullRequestUrl: z5.string().optional(),
   /** The PR this task is ABOUT (#407) — auto-discovered from conversation references. Display
    *  tier only: `pullRequestUrl` (the PR this task CREATED) wins, and the action gates ignore it. */
-  referencedPullRequestUrl: z4.string().optional(),
+  referencedPullRequestUrl: z5.string().optional(),
   /** The PR/issue number this task is ABOUT (task auto-naming spec) — display tier only. */
-  prNumber: z4.number().optional(),
-  issueNumber: z4.number().optional(),
+  prNumber: z5.number().optional(),
+  issueNumber: z5.number().optional(),
   /** Server-side provenance: referenced-issue discovery currently owns `issueNumber`. */
-  referencedIssueNumberSeeded: z4.boolean().optional(),
+  referencedIssueNumberSeeded: z5.boolean().optional(),
   /** 'user' = renamed via PATCH, never auto-overwritten; 'marker' = agent-declared via
    *  CEZ:TITLE (spec 2026-07-18-task-ref-markers); 'auto' = namer-owned. */
-  titleOrigin: z4.enum(["user", "auto", "marker"]).optional(),
+  titleOrigin: z5.enum(["user", "auto", "marker"]).optional(),
   /** References the agent declared via CEZ:PR/CEZ:ISSUE markers — authoritative over the namer
    *  for the matching kind. */
-  markerRefs: z4.object({ pr: z4.number().optional(), issue: z4.number().optional() }).optional(),
+  markerRefs: z5.object({ pr: z5.number().optional(), issue: z5.number().optional() }).optional(),
   /** The referenced tier's working set (distinct PR URLs spotted, capped server-side). */
-  referencedPrCandidates: z4.array(z4.string()).optional(),
+  referencedPrCandidates: z5.array(z5.string()).optional(),
   /** The issue this task is ABOUT (spec 2026-07-21-report-ref-discovery). Display-only. */
-  referencedIssueUrl: z4.string().optional(),
+  referencedIssueUrl: z5.string().optional(),
   /** The referenced-issue working set, persisted like `referencedPrCandidates`. Capped. */
-  referencedIssueCandidates: z4.array(z4.string()).optional(),
+  referencedIssueCandidates: z5.array(z5.string()).optional(),
   /** Explicit execution policy. `false` means the run intentionally uses the repo root;
    *  absent on older runs and for the default isolated-worktree mode. */
-  worktree: z4.literal(false).optional(),
+  worktree: z5.literal(false).optional(),
   /** Absent for in-place runs and after an isolated worktree is removed. */
-  worktreePath: z4.string().optional(),
-  branch: z4.string().optional(),
+  worktreePath: z5.string().optional(),
+  branch: z5.string().optional(),
   /** Stable baseline for session git views: a worktree's fork ref, or an in-place run's starting commit. */
-  baseBranch: z4.string().optional(),
+  baseBranch: z5.string().optional(),
   /** Set when count-based retention (#483) reclaimed the worktree DIRECTORY (the branch is
    *  kept): the dir is gone but recoverable. */
-  worktreeReclaimedAt: z4.string().optional(),
+  worktreeReclaimedAt: z5.string().optional(),
   /** Parallel variants (spec 010): runs sharing a groupId are one group. */
-  groupId: z4.string().optional(),
+  groupId: z5.string().optional(),
   /** Variant letter within the group — 'A' | 'B' | 'C'. */
-  variant: z4.string().optional(),
-  peakRssBytes: z4.number().optional(),
-  peakProcCount: z4.number().optional(),
-  archived: z4.boolean(),
-  archivedAt: z4.string().optional(),
+  variant: z5.string().optional(),
+  peakRssBytes: z5.number().optional(),
+  peakProcCount: z5.number().optional(),
+  archived: z5.boolean(),
+  archivedAt: z5.string().optional(),
   /** Read receipt (#unread-done-items): ISO time the cockpit last opened this run's
    *  thread. A finished (`done`/`failed`) run reads as *unread* until seen since it
    *  finished — see `isUnread()` in the cockpit's `lib/read-state.ts`. Absent on old
-   *  runs and on any run not yet opened, both of which count as unread. */
-  seenAt: z4.string().optional(),
-  currentStepId: z4.string().optional(),
-  error: z4.string().optional(),
-  steps: z4.array(stepStateSchema),
+   *  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),
   /**
    * The persisted workflow definition, so a `queued` run survives a restart — including the ad-hoc
    * "(planned)" chains that exist nowhere else.
@@ -350,206 +586,299 @@ var runRecordSchema = z4.object({
 var apiRunSchema = runRecordSchema.extend({
   usage: processUsageSchema.optional()
 });
-var createRunResponseSchema = z4.union([
+var runIndexEntrySchema = z5.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(),
+  status: runStatusSchema,
+  activity: runActivitySchema.optional(),
+  createdAt: z5.string(),
+  finishedAt: z5.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(),
+  /** 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(),
+  /** 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(),
+  /** 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(),
+  /** 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(),
+  /** 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(),
+  /**
+   * 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
+   * server, because the rule that picks between them is subtle (#407, #526: a run that REVIEWED
+   * a PR must not claim it as its own, an issue-subject run must not adopt an incidental
+   * transcript PR) and it already exists, tested, on the client. Resolving it a second time
+   * server-side would be a second rule, and the two would drift.
+   *
+   * 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(),
+  /** 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(),
+  /** 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(),
+  /**
+   * 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.
+   *
+   * It can ride a WORKSPACE-level answer because the sampler is process-wide: one cezar process
+   * runs every project's agents, so `currentUsage(runId)` knows about a run whatever project it
+   * belongs to. That is what lets a cross-project table show live usage without opening one
+   * event stream per project (it could not — the run stream is project-scoped).
+   */
+  usage: processUsageSchema.optional()
+});
+var referenceStatusesByProjectSchema = z5.record(
+  z5.string(),
+  z5.object({
+    prs: z5.record(z5.number(), referenceStatusSchema),
+    issues: z5.record(z5.number(), referenceStatusSchema)
+  })
+);
+var runsIndexResponseSchema = z5.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),
+  /** Additive: absent statuses mean "nothing warm", never "nothing to show". */
+  referenceStatuses: referenceStatusesByProjectSchema,
+  /** The per-project cap that produced this list. */
+  perProjectLimit: z5.number(),
+  /** Ids of the projects that had more runs than the cap allowed. */
+  truncated: z5.array(z5.string())
+});
+var createRunResponseSchema = z5.union([
   runRecordSchema,
-  z4.object({ runs: z4.array(runRecordSchema) })
+  z5.object({ runs: z5.array(runRecordSchema) })
 ]);
-var cancelResponseSchema = z4.object({ cancelled: z4.boolean() });
-var archiveFinishedResponseSchema = z4.object({ archived: z4.number() });
-var markAllReadResponseSchema = z4.object({ read: z4.number() });
-var deleteRunResponseSchema = z4.object({ deleted: z4.literal(true) });
-var finishResponseSchema = z4.object({ finished: z4.literal(true) });
-var continueResponseSchema = z4.object({ continued: z4.literal(true) });
-var createPrResponseSchema = z4.object({
-  url: z4.string(),
-  dryRun: z4.boolean()
-});
-var messageResponseSchema = z4.union([
-  z4.object({ delivered: z4.literal(true) }),
-  z4.object({ queued: z4.literal(true), message: queuedMessageSchema }),
-  z4.object({ deferred: z4.literal(true) })
+var 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 editQueuedMessageResponseSchema = z4.object({ message: queuedMessageSchema });
-var removeQueuedMessageResponseSchema = z4.object({ removed: z4.literal(true) });
-var openInCliResponseSchema = z4.object({
-  opened: z4.literal(true),
-  command: z4.string()
-});
-var removeWorktreeResponseSchema = z4.object({ removed: z4.literal(true) });
-var gitCommitResponseSchema = z4.object({
-  committed: z4.literal(true),
-  sha: z4.string()
-});
-var gitPushResponseSchema = z4.object({
-  pushed: z4.literal(true),
-  branch: z4.string(),
-  remote: z4.string(),
-  upstreamSet: z4.boolean()
-});
-var runCommitSchema = z4.object({
-  sha: z4.string(),
-  subject: z4.string(),
-  author: z4.string(),
+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(),
   /** Relative time ("3 hours ago") — git's `%cr`. */
-  when: z4.string()
+  when: z5.string()
 });
-var runCommitsResponseSchema = z4.object({ commits: z4.array(runCommitSchema) });
-var groupVariantSchema = z4.object({
-  id: z4.string(),
+var runCommitsResponseSchema = z5.object({ commits: z5.array(runCommitSchema) });
+var groupVariantSchema = z5.object({
+  id: z5.string(),
   /** 'A' | 'B' | 'C' in practice; `'?'` for a record that lost its letter. */
-  variant: z4.string(),
-  title: z4.string(),
+  variant: z5.string(),
+  title: z5.string(),
   status: runStatusSchema,
-  archived: z4.boolean(),
-  tokensUsed: z4.number(),
+  archived: z5.boolean(),
+  tokensUsed: z5.number(),
   inputTokens: usageCounterSchema.optional(),
   outputTokens: usageCounterSchema.optional(),
-  costUsd: z4.number().optional(),
-  diffStat: z4.string(),
+  costUsd: z5.number().optional(),
+  diffStat: z5.string(),
   /** First lines of the handoff journal's "## Progress log" section, as markdown. */
-  handoffExcerpt: z4.string()
+  handoffExcerpt: z5.string()
 });
-var groupResponseSchema = z4.object({
-  groupId: z4.string(),
-  runs: z4.array(groupVariantSchema)
+var groupResponseSchema = z5.object({
+  groupId: z5.string(),
+  runs: z5.array(groupVariantSchema)
 });
-var pickVariantResponseSchema = z4.object({
+var pickVariantResponseSchema = z5.object({
   winner: runRecordSchema.optional()
 });
-var imageInputSchema = z4.object({
-  mediaType: z4.string().regex(/^image\//),
-  data: z4.string().min(1).max(7e6)
+var imageInputSchema = z5.object({
+  mediaType: z5.string().regex(/^image\//),
+  data: z5.string().min(1).max(7e6)
 });
-var createRunInputBaseSchema = z4.object({
-  workflow: z4.string().min(1).optional(),
+var createRunInputBaseSchema = z5.object({
+  workflow: z5.string().min(1).optional(),
   /** An inline chain (spec 008 — an approved plan runs as an ad-hoc workflow, never written to
    *  a file). The catalog's own step shape, not a copy of it. */
-  steps: z4.array(workflowStepDefSchema).min(1).max(8).optional(),
-  task: z4.string().min(1).max(1e5, "must be at most 100000 characters"),
-  model: z4.string().optional(),
+  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(),
   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(),
   /** 1–3. Above 1 the response is `{ runs }` rather than a single record. */
-  variants: z4.number().int().min(1).max(3).optional(),
+  variants: z5.number().int().min(1).max(3).optional(),
   /** false → run in the repo working tree instead of an isolated worktree (read-only skills).
    *  Omit for the default. Ignored server-side when variants > 1. */
-  worktree: z4.boolean().optional(),
+  worktree: z5.boolean().optional(),
   /** true → autonomous run: never parks at "waiting"; auto-continues until done. */
-  autonomous: z4.boolean().optional(),
+  autonomous: z5.boolean().optional(),
   /** false → keep the handoff journal but do not expose or request a follow-up todos file.
    *  Omit for the default (enabled); a server with the capability off pins it to false. */
-  generateFollowups: z4.boolean().optional(),
+  generateFollowups: z5.boolean().optional(),
   /** Per-run system-prompt override (R2 2.3) — programmatic callers only. Wins over the
    *  config.json default; whitespace-only degrades to absent. */
-  systemPrompt: z4.string().trim().max(2e4, "must be at most 20000 characters").optional().transform((s) => s ? s : void 0),
+  systemPrompt: z5.string().trim().max(2e4, "must be at most 20000 characters").optional().transform((s) => s ? s : void 0),
   /** Screenshots pasted into the new-task form; delivered with the first agent step. */
-  images: z4.array(imageInputSchema).max(4).optional(),
+  images: z5.array(imageInputSchema).max(4).optional(),
   /** The inbox entry this task came from (#374). Best-effort bookkeeping: an unknown or
    *  already-started id never fails the run. For ×2/×3 the FIRST variant is recorded. */
-  todoId: z4.string().min(1).max(200, "must be at most 200 characters").optional()
+  todoId: z5.string().min(1).max(200, "must be at most 200 characters").optional()
 });
 var createRunInputSchema = createRunInputBaseSchema.refine(
   (b) => Boolean(b.workflow) !== Boolean(b.steps),
   { message: 'provide either "workflow" or "steps", not both' }
 );
-var messageInputSchema = z4.object({
-  text: z4.string().max(1e5).default(""),
-  images: z4.array(imageInputSchema).max(4).default([])
+var messageInputSchema = z5.object({
+  text: z5.string().max(1e5).default(""),
+  images: z5.array(imageInputSchema).max(4).default([])
 }).refine((m) => m.text.trim().length > 0 || m.images.length > 0, {
   message: "message needs text or at least one image"
 });
-var patchRunInputSchema = z4.object({
-  title: z4.string().trim().min(1).max(300).optional(),
-  task: z4.string().trim().min(1).max(1e5).optional()
+var patchRunInputSchema = z5.object({
+  title: z5.string().trim().min(1).max(300).optional(),
+  task: z5.string().trim().min(1).max(1e5).optional()
 });
 
 // ../contract/src/repo.ts
-import { z as z5 } from "zod";
-var statusEntrySchema = z5.object({
-  status: z5.string(),
-  path: z5.string()
+import { z as z6 } from "zod";
+var statusEntrySchema = z6.object({
+  status: z6.string(),
+  path: z6.string()
 });
-var logEntrySchema = z5.object({
-  hash: z5.string(),
-  subject: z5.string(),
-  author: z5.string(),
-  when: z5.string()
+var logEntrySchema = z6.object({
+  hash: z6.string(),
+  subject: z6.string(),
+  author: z6.string(),
+  when: z6.string()
 });
-var repoResponseSchema = z5.union([
-  z5.object({
-    info: z5.null(),
-    status: z5.array(z5.never()),
-    log: z5.array(z5.never()),
-    branches: z5.array(z5.never()),
-    baseBranch: z5.null()
+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()
   }),
-  z5.object({
+  z6.object({
     info: repoInfoSchema,
-    status: z5.array(statusEntrySchema),
-    log: z5.array(logEntrySchema),
-    branches: z5.array(z5.string()),
-    baseBranch: z5.string().nullable()
+    status: z6.array(statusEntrySchema),
+    log: z6.array(logEntrySchema),
+    branches: z6.array(z6.string()),
+    baseBranch: z6.string().nullable()
   })
 ]);
-var repoBranchResponseSchema = z5.object({
-  branch: z5.string(),
-  created: z5.boolean()
+var repoBranchResponseSchema = z6.object({
+  branch: z6.string(),
+  created: z6.boolean()
 });
-var diffStatSchema2 = z5.object({
-  adds: z5.number(),
-  dels: z5.number(),
-  files: z5.number()
+var diffStatSchema2 = z6.object({
+  adds: z6.number(),
+  dels: z6.number(),
+  files: z6.number()
 });
-var changedFileSchema = z5.object({
-  path: z5.string(),
+var changedFileSchema = z6.object({
+  path: z6.string(),
   /** Rename/copy source — present only when `status` is renamed/copied. */
-  oldPath: z5.string().optional(),
-  status: z5.enum(["added", "modified", "deleted", "renamed", "copied"]),
-  adds: z5.number(),
-  dels: z5.number(),
+  oldPath: z6.string().optional(),
+  status: z6.enum(["added", "modified", "deleted", "renamed", "copied"]),
+  adds: z6.number(),
+  dels: z6.number(),
   /** Binary per numstat — there is no text patch to render. */
-  binary: z5.boolean(),
+  binary: z6.boolean(),
   /** True when the path is one the raw-bytes route serves as an `<img>` (#365) — present only
    *  when true, so old clients that never read it stay correct. */
-  image: z5.boolean().optional(),
+  image: z6.boolean().optional(),
   /** This file's unified-diff section; possibly `… (patch truncated)`, possibly empty. */
-  patch: z5.string()
+  patch: z6.string()
 });
-var changesPayloadSchema = z5.object({
-  files: z5.array(changedFileSchema),
+var changesPayloadSchema = z6.object({
+  files: z6.array(changedFileSchema),
   stat: diffStatSchema2,
   /** Additive context for review tasks whose worktree HEAD no longer matches their own branch. */
-  repointedHead: z5.object({ headBranch: z5.string(), taskBranch: z5.string() }).optional()
+  repointedHead: z6.object({ headBranch: z6.string(), taskBranch: z6.string() }).optional()
 });
-var repoCommitPayloadSchema = z5.object({
-  sha: z5.string(),
-  subject: z5.string(),
-  author: z5.string(),
+var repoCommitPayloadSchema = z6.object({
+  sha: z6.string(),
+  subject: z6.string(),
+  author: z6.string(),
   /** Relative time ("3 hours ago") — same `%cr` format as the /api/v1/repo log. */
-  when: z5.string(),
-  files: z5.array(changedFileSchema),
+  when: z6.string(),
+  files: z6.array(changedFileSchema),
   stat: diffStatSchema2
 });
-var worktreeDirEntrySchema = z5.object({
-  name: z5.string(),
-  type: z5.enum(["dir", "file"]),
-  size: z5.number().optional()
+var worktreeDirEntrySchema = z6.object({
+  name: z6.string(),
+  type: z6.enum(["dir", "file"]),
+  size: z6.number().optional()
 });
-var worktreeEntrySchema = z5.discriminatedUnion("type", [
-  z5.object({
-    type: z5.literal("dir"),
-    path: z5.string(),
-    entries: z5.array(worktreeDirEntrySchema)
+var worktreeEntrySchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("dir"),
+    path: z6.string(),
+    entries: z6.array(worktreeDirEntrySchema)
   }),
-  z5.object({
-    type: z5.literal("file"),
-    path: z5.string(),
-    size: z5.number(),
-    binary: z5.boolean(),
-    tooLarge: z5.boolean(),
-    content: z5.string().optional()
+  z6.object({
+    type: z6.literal("file"),
+    path: z6.string(),
+    size: z6.number(),
+    binary: z6.boolean(),
+    tooLarge: z6.boolean(),
+    content: z6.string().optional()
   })
 ]);
-var worktreeRunStatusSchema = z5.enum([
+var worktreeRunStatusSchema = z6.enum([
   "queued",
   "running",
   "waiting",
@@ -558,185 +887,23 @@ var worktreeRunStatusSchema = z5.enum([
   "failed",
   "cancelled"
 ]);
-var worktreeInfoSchema = z5.object({
-  runId: z5.string(),
-  title: z5.string(),
-  status: worktreeRunStatusSchema,
-  branch: z5.string().nullable(),
-  sizeBytes: z5.number().nullable(),
-  finishedAt: z5.string().nullable(),
-  reclaimable: z5.boolean()
-});
-var worktreesResponseSchema = z5.object({
-  worktrees: z5.array(worktreeInfoSchema),
-  totalBytes: z5.number().nullable(),
-  keep: z5.number()
-});
-var reclaimWorktreesResponseSchema = z5.object({
-  reclaimed: z5.array(z5.string())
-});
-
-// ../contract/src/github.ts
-import { z as z6 } from "zod";
-var checksGlyphSchema = z6.enum(["passing", "failing", "pending"]).nullable();
-var githubItemSchema = z6.object({
-  kind: z6.enum(["issue", "pr"]),
-  number: z6.number(),
+var worktreeInfoSchema = z6.object({
+  runId: z6.string(),
   title: z6.string(),
-  author: z6.string(),
-  createdAt: z6.string(),
-  labels: z6.array(z6.string()),
-  body: z6.string(),
-  url: z6.string(),
-  comments: z6.number(),
-  /** PRs only. */
-  isDraft: z6.boolean().optional(),
-  additions: z6.number().optional(),
-  deletions: z6.number().optional(),
-  checks: checksGlyphSchema.optional()
-});
-var githubDataSchema = z6.object({
-  available: z6.boolean(),
-  /** Why it is unavailable (`gh` missing, no remote, offline…). Never an error — a hint. */
-  reason: z6.string().optional(),
-  /** owner/name, when known. */
-  repo: z6.string().optional(),
-  syncedAt: z6.string().optional(),
-  issues: z6.array(githubItemSchema),
-  prs: z6.array(githubItemSchema),
-  /** Repo-wide label name → 6-hex color (no `#`); lets chips tint like GitHub. Additive. */
-  labelColors: z6.record(z6.string(), z6.string()).optional()
-});
-var githubChecksDataSchema = z6.discriminatedUnion("available", [
-  z6.object({
-    available: z6.literal(true),
-    checks: z6.record(z6.number(), checksGlyphSchema)
-  }),
-  z6.object({
-    available: z6.literal(false),
-    reason: z6.string()
-  })
-]);
-var githubCommentSchema = z6.object({
-  id: z6.number(),
-  /** Author login, `'?'` fallback when gh omits the user. */
-  author: z6.string(),
-  avatarUrl: z6.string().optional(),
-  createdAt: z6.string(),
-  body: z6.string(),
-  kind: z6.enum(["comment", "review"]),
-  /** Reviews only — drives the state chip. */
-  reviewState: z6.enum(["approved", "changes_requested", "commented", "dismissed"]).optional(),
-  url: z6.string()
-});
-var githubTimelineEventKindSchema = z6.enum([
-  "committed",
-  "labeled",
-  "unlabeled",
-  "assigned",
-  "unassigned",
-  "merged",
-  "closed",
-  "reopened",
-  "head_ref_force_pushed",
-  "cross-referenced",
-  "renamed"
-]);
-var githubTimelineEventSchema = z6.object({
-  id: z6.string(),
-  kind: githubTimelineEventKindSchema,
-  /** Login — or the git author name for `committed`, which carries no GitHub actor. */
-  actor: z6.string(),
-  /** Absent for `committed`. */
-  avatarUrl: z6.string().optional(),
-  createdAt: z6.string(),
-  url: z6.string().optional(),
-  /** `committed` — full 40-char SHA. */
-  sha: z6.string().optional(),
-  /** `committed` — first line, capped at 120 chars. */
-  message: z6.string().optional(),
-  /** `committed` — **absent** (lookup failed/skipped) and **`null`** (no CI configured) both
-   *  render no glyph, but stay distinct values. */
-  checks: checksGlyphSchema.optional(),
-  label: z6.object({ name: z6.string(), color: z6.string().optional() }).optional(),
-  /** `assigned`/`unassigned` login, or the new title for `renamed`. */
-  subject: z6.string().optional(),
-  refNumber: z6.number().optional(),
-  refTitle: z6.string().optional(),
-  refIsPr: z6.boolean().optional()
-});
-var githubCommentsDataSchema = z6.object({
-  available: z6.boolean(),
-  reason: z6.string().optional(),
-  /** Chronological, oldest first. */
-  comments: z6.array(githubCommentSchema),
-  /** True when either stream hit its cap, or the timeline fetch stopped short. */
-  truncated: z6.boolean().optional(),
-  /** Timeline events (#525) — additive; absent when the server degraded to the legacy
-   *  comments-only fetch. Capped independently of `comments`. */
-  events: z6.array(githubTimelineEventSchema).optional()
+  status: worktreeRunStatusSchema,
+  branch: z6.string().nullable(),
+  sizeBytes: z6.number().nullable(),
+  finishedAt: z6.string().nullable(),
+  reclaimable: z6.boolean()
 });
-var githubMergeMethodSchema = z6.enum(["merge", "squash", "rebase"]);
-var githubPrCheckSchema = z6.object({
-  name: z6.string(),
-  state: z6.enum(["passing", "failing", "pending", "unknown"]),
-  required: z6.boolean().nullable(),
-  url: z6.string().optional()
+var worktreesResponseSchema = z6.object({
+  worktrees: z6.array(worktreeInfoSchema),
+  totalBytes: z6.number().nullable(),
+  keep: z6.number()
 });
-var githubPrMergeStateSchema = z6.object({
-  number: z6.number(),
-  title: z6.string(),
-  url: z6.string(),
-  state: z6.enum(["open", "closed", "merged"]),
-  isDraft: z6.boolean(),
-  headRef: z6.string(),
-  baseRef: z6.string(),
-  headSha: z6.string(),
-  mergeable: z6.enum(["mergeable", "conflicting", "unknown"]),
-  reviewDecision: z6.enum(["approved", "changes-requested", "review-required", "unknown"]),
-  checks: z6.array(githubPrCheckSchema),
-  methods: z6.array(githubMergeMethodSchema),
-  defaultMethod: githubMergeMethodSchema.nullable(),
-  eligibility: z6.enum(["ready", "blocked", "pending", "unauthorized", "terminal", "unknown"]),
-  blockers: z6.array(z6.object({ code: z6.string(), message: z6.string() })),
-  canMerge: z6.boolean(),
-  canOverride: z6.boolean()
-});
-var githubPrMergeStateResponseSchema = z6.discriminatedUnion("available", [
-  z6.object({ available: z6.literal(true), mergeState: githubPrMergeStateSchema }),
-  z6.object({ available: z6.literal(false), reason: z6.string() })
-]);
-var githubMergeResponseSchema = z6.object({
-  merged: z6.literal(true),
-  number: z6.number(),
-  url: z6.string(),
-  method: githubMergeMethodSchema,
-  mergeCommitSha: z6.string().optional()
+var reclaimWorktreesResponseSchema = z6.object({
+  reclaimed: z6.array(z6.string())
 });
-var githubPrChangeSchema = z6.object({
-  path: z6.string(),
-  previousPath: z6.string().optional(),
-  status: z6.enum(["added", "modified", "removed", "renamed", "copied", "changed"]),
-  additions: z6.number(),
-  deletions: z6.number(),
-  patch: z6.string().optional(),
-  patchUnavailableReason: z6.enum(["binary", "too-large", "not-provided"]).optional(),
-  truncated: z6.boolean().optional()
-});
-var githubPrChangesDataSchema = z6.discriminatedUnion("available", [
-  z6.object({
-    available: z6.literal(true),
-    number: z6.number(),
-    headSha: z6.string(),
-    files: z6.array(githubPrChangeSchema),
-    additions: z6.number(),
-    deletions: z6.number(),
-    truncated: z6.boolean(),
-    /** Present when the payload is complete but partial in some other way (a capped patch). */
-    reason: z6.string().optional()
-  }),
-  z6.object({ available: z6.literal(false), reason: z6.string() })
-]);
 
 // ../contract/src/projects.ts
 import { z as z7 } from "zod";
@@ -755,9 +922,31 @@ var projectListEntrySchema = z7.object({
   /** 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(),
+  /**
+   * 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
+   * cockpit. Omitted when the project has no forge remote.
+   *
+   * It exists for the cross-project surfaces: a run often knows a PR or issue only by NUMBER, and
+   * 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(),
   /** 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: z7.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.
+   * The global Tasks page (`/tasks`) filters and groups by them.
+   *
+   * Omitted rather than `[]` when a project has none, exactly like `maxParallel`: the registry
+   * stores nothing for a project nobody has tagged, and an empty array on the wire would make
+   * "never tagged" indistinguishable from "tagged, then emptied" for no gain. Normalized
+   * server-side (trimmed, deduped case-insensitively, sorted), so a consumer may compare them
+   * directly.
+   */
+  tags: z7.array(z7.string()).optional()
 });
 var projectsResponseSchema = z7.object({
   projects: z7.array(projectListEntrySchema),
@@ -775,9 +964,15 @@ var removeProjectResponseSchema = z7.object({
 var updateProjectResponseSchema = z7.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()
-});
+  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()
+}).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(),
@@ -826,8 +1021,27 @@ var workspaceConfigResponseSchema = z8.object({
     maxParallel: z8.number(),
     maxMonitoringSessions: z8.number(),
     monitoringWakeIntervalMinutes: z8.number().nullable(),
+    /** Resume a run a provider usage limit stopped, once the limit resets. Default `true`. */
+    autoResumeOnUsageLimit: z8.boolean(),
     memoryLimitMb: z8.number().nullable(),
     worktreeRetentionDefault: z8.number()
+  }),
+  /**
+   * What a repo that has set none of its own runs (spec 2026-07-29-agent-profiles).
+   *
+   * Both keys are OPTIONAL on the wire, and that is load-bearing rather than lax: absent means
+   * "this machine has no opinion, the built-in default applies", and it has to stay distinguishable
+   * from a value someone chose or the fallback collapses into "always claude". Consulted only where
+   * the repo's own `.ai/cezar/config.json` is silent — a repo that chose is never overruled.
+   */
+  agentDefaults: z8.object({
+    runner: runnerSchema.optional(),
+    models: z8.object({
+      claude: z8.string().optional(),
+      codex: z8.string().optional(),
+      opencode: z8.string().optional(),
+      pi: z8.string().optional()
+    }).optional()
   })
 });
 var setWorkspaceConfigInputSchema = z8.object({
@@ -838,17 +1052,34 @@ var setWorkspaceConfigInputSchema = z8.object({
     autonomous: z8.boolean().nullable().optional(),
     worktree: z8.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({
+    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()
+    }).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(),
     memoryLimitMb: z8.number().int().min(0).max(1048576).nullable().optional(),
     worktreeRetentionDefault: z8.number().int().min(0).max(1e3).optional()
   }).optional()
 });
 var appearanceSchema = z8.object({
   accent: z8.enum(["lime", "violet"]).optional(),
-  density: z8.enum(["comfortable", "compact", "ultra"]).optional()
+  density: z8.enum(["comfortable", "compact", "ultra"]).optional(),
+  width: z8.enum(["narrow", "wide"]).optional()
+});
+var taskTableUiStateSchema = z8.looseObject({
+  /** Explicit user choices only. Missing ids keep the registry-owned default. */
+  expandedColumns: z8.record(z8.string(), z8.boolean()).optional()
 });
 var uiStateSchema = z8.looseObject({
   lastTask: z8.object({ source: z8.enum(["workflow", "skill"]), ref: z8.string() }).optional(),
@@ -902,7 +1133,8 @@ var workspaceUiStateSchema = z8.looseObject({
   dismissedProviderAuthFailures: z8.object({
     claude: z8.string().optional(),
     codex: z8.string().optional(),
-    opencode: z8.string().optional()
+    opencode: z8.string().optional(),
+    pi: z8.string().optional()
   }).optional(),
   /** Settings → Appearance, GLOBAL since step 3.5: accent + density describe the person at the
    *  keyboard, not a repo. */
@@ -910,6 +1142,8 @@ var workspaceUiStateSchema = z8.looseObject({
   /** 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(),
+  /** 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
    *  entering at the exact bare root. The shape is unchanged and still accepted, but the current
    *  cockpit keeps it in localStorage (`packages/web/src/lib/last-location.ts`): stored here, the
@@ -920,16 +1154,48 @@ var workspaceUiStateSchema = z8.looseObject({
    *  show from that repo. */
   importedSkills: z8.array(z8.string()).optional()
 });
+var WORKSPACE_UI_STATE_MAX_KEYS = 200;
+var TASK_TABLE_MAX_COLUMNS = 50;
+var setWorkspaceUiStateInputSchema = z8.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, {
+      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()
+  }).optional(),
+  importedSkills: z8.array(z8.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, {
+      message: `taskTable.expandedColumns must have at most ${TASK_TABLE_MAX_COLUMNS} entries`
+    }).optional()
+  }).optional()
+}).superRefine((data, ctx) => {
+  if (Object.keys(data).length > WORKSPACE_UI_STATE_MAX_KEYS) {
+    ctx.addIssue({
+      code: "custom",
+      message: `ui-state has too many keys (max ${WORKSPACE_UI_STATE_MAX_KEYS})`
+    });
+  }
+});
 var runnerModelsSchema = z8.object({
   claude: z8.string().optional(),
   codex: z8.string().optional(),
-  opencode: z8.string().optional()
+  opencode: z8.string().optional(),
+  pi: z8.string().optional()
 });
 var configResponseSchema = z8.object({
   baseBranch: z8.string().nullable(),
   defaultRunner: runnerSchema,
   systemPrompt: z8.string().nullable(),
   defaultModels: runnerModelsSchema,
+  /** True when native coding-agent settings are authoritative and model picks are read-only. */
+  modelsLocked: z8.boolean(),
   /** How many tasks run at once (1–16). */
   maxParallel: z8.number(),
   /** Per-task memory ceiling in MiB (whole process tree); null = no limit. */
@@ -951,7 +1217,8 @@ var setConfigInputSchema = z8.object({
   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()
+    opencode: z8.string().trim().max(200).nullable().optional(),
+    pi: z8.string().trim().max(200).nullable().optional()
   }).optional(),
   maxParallel: z8.number().int().min(1).max(16).optional(),
   /** null or 0 clears the ceiling back to "no limit". */
@@ -1003,7 +1270,12 @@ var providerStatusSchema = z8.object({
   status: providerConnectionStateSchema,
   enabled: z8.boolean().optional(),
   hint: z8.string().optional(),
-  authFailureId: z8.string().optional()
+  authFailureId: z8.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()
 });
 var providerStatusResponseSchema = z8.object({
   providers: z8.array(providerStatusSchema)
@@ -1012,6 +1284,11 @@ 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 modelDiscoveryRunnerSchema = z8.enum(["codex", "opencode"]);
+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(),
@@ -1034,6 +1311,14 @@ var openTargetSchema = z8.object({
 var openTargetsResponseSchema = z8.object({
   targets: z8.array(openTargetSchema)
 });
+var openProjectInSchema = z8.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)
+});
+var openProjectInResponseSchema = z8.object({
+  opened: z8.literal(true),
+  path: z8.string()
+});
 
 // ../contract/src/skills.ts
 import { z as z9 } from "zod";
@@ -1144,69 +1429,182 @@ var setAgentConfigInputSchema = z10.object({
   version: z10.string().nullable()
 });
 
-// ../contract/src/automations.ts
+// ../contract/src/agent-profiles.ts
 import { z as z11 } from "zod";
-var automationEventSchema = z11.enum([
+var DEFAULT_AGENT_ACCOUNT_ID = "default";
+var agentAccountFileSchema = z11.object({
+  id: z11.string(),
+  /** e.g. `settings.json` — the file's own name, since the folder is shown once on the account. */
+  label: z11.string(),
+  /** Absolute, resolved inside this account's config folder. */
+  path: z11.string(),
+  exists: z11.boolean()
+});
+var agentProfileSchema = z11.object({
+  /** `default` for the discovered profile, else the stored slug. */
+  id: z11.string(),
+  provider: providerIdSchema,
+  label: z11.string(),
+  /** As the user wrote it — a literal `~` is preserved, matching `browseRoot`/`projectsDir`. */
+  configDir: z11.string(),
+  /** Expanded absolute path. Same-origin route, like `ProjectListEntry.root`. */
+  path: z11.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(),
+  /** 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(),
+  /** True for the profile cezar discovers from the environment. Never stored, never deletable. */
+  isDefault: z11.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
+   *  listing refuses to pay that (it would be one spawn per provider plus one per account, on
+   *  every cold load); it serves only what is already cached, exactly as `GET /api/v1/health`
+   *  serves a cached forge answer. Absent means "not determined yet" — NOT `unknown`, which is a
+   *  real probe result — and the cockpit fills it in from `…/:id/status`. */
+  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)
+});
+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),
+  /** 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),
+  /** Which account each project uses, keyed by the project's realpath'd ROOT.
+   *
+   *  Served here rather than on `GET /api/v1/projects` because it is stored beside the accounts it
+   *  names (`~/.cezar/agent-accounts.json`) — one file, so deleting an account and scrubbing every
+   *  reference to it is one atomic write, and neither can be dropped by a cezar version that never
+   *  heard of accounts. Empty in hosted mode, where the whole family is withheld. */
+  selections: z11.record(z11.string(), agentAccountSelectionSchema),
+  /** The machine-wide fallback account per provider, used by any repo that has chosen none. */
+  defaults: agentAccountSelectionSchema
+});
+var selectAgentProfileInputSchema = z11.object({
+  /**
+   * Registry slug, or the reserved `default` boot alias. Resolved to a root server-side.
+   *
+   * `null` targets the MACHINE-WIDE default instead of one repo — the account a repo that has
+   * 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(),
+  provider: providerIdSchema,
+  profileId: z11.string().max(64).nullable()
+});
+var agentProfileSelectionsResponseSchema = z11.object({
+  selections: z11.record(z11.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 openAgentAccountFileInputSchema = z11.object({
+  file: z11.string().min(1).max(200),
+  target: z11.string().min(1).max(64).optional()
+});
+var openAgentAccountFileResponseSchema = z11.object({
+  opened: z11.literal(true),
+  path: z11.string()
+});
+var createAgentProfileInputSchema = z11.object({
+  provider: providerIdSchema,
+  label: z11.string().trim().max(200).optional(),
+  /** Stored as written; validated absolute after `~` expansion, server-side. */
+  configDir: z11.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 removeAgentProfileResponseSchema = z11.object({
+  removed: z11.literal(true),
+  id: z11.string()
+});
+
+// ../contract/src/automations.ts
+import { z as z12 } from "zod";
+var automationEventSchema = z12.enum([
   "pull_request.opened",
   "issue.opened",
   "issue.labeled",
   "issue.unlabeled"
 ]);
-var automationFiltersSchema = z11.object({
-  authors: z11.array(z11.string()).optional(),
-  assignees: z11.array(z11.string()).optional(),
-  allLabels: z11.array(z11.string()).optional(),
-  anyLabels: z11.array(z11.string()).optional(),
-  excludeLabels: z11.array(z11.string()).optional(),
+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(),
   /** Required for the two label events — the server rejects a definition without it. */
-  changedLabels: z11.array(z11.string()).optional(),
-  lookbackDays: z11.number(),
-  maxRecords: z11.number()
+  changedLabels: z12.array(z12.string()).optional(),
+  lookbackDays: z12.number(),
+  maxRecords: z12.number()
 });
 var automationTaskSchema = createRunInputBaseSchema.omit({ task: true, images: true, todoId: true, systemPrompt: true }).extend({
   /** The prompt template. `{{github.number}}`, `{{github.title}}`, `{{github.url}}` and
    *  `{{github.labels}}` are substituted per match; GitHub content is appended as untrusted
    *  context, never interpolated into instructions. */
-  prompt: z11.string(),
-  variants: z11.union([z11.literal(1), z11.literal(2), z11.literal(3)]).optional(),
-  systemPrompt: z11.string().optional()
+  prompt: z12.string(),
+  variants: z12.union([z12.literal(1), z12.literal(2), z12.literal(3)]).optional(),
+  systemPrompt: z12.string().optional()
 });
-var automationDefinitionSchema = z11.object({
-  id: z11.string(),
+var automationDefinitionSchema = z12.object({
+  id: z12.string(),
   /** Bumped on every edit; a PUT must echo the revision it read (optimistic concurrency). */
-  revision: z11.number(),
-  name: z11.string(),
-  description: z11.string().optional(),
+  revision: z12.number(),
+  name: z12.string(),
+  description: z12.string().optional(),
   /** Always present: the storage schema defaults it to `false`, so a definition is created
    *  PAUSED and enabling it is a separate, baseline-establishing act. */
-  enabled: z11.boolean(),
-  events: z11.array(automationEventSchema),
-  intervalSeconds: z11.number(),
+  enabled: z12.boolean(),
+  events: z12.array(automationEventSchema),
+  intervalSeconds: z12.number(),
   filters: automationFiltersSchema,
   task: automationTaskSchema,
-  createdAt: z11.string(),
-  updatedAt: z11.string()
+  createdAt: z12.string(),
+  updatedAt: z12.string()
 });
-var automationCursorSchema = z11.object({
-  timestamp: z11.string(),
-  tieBreaker: z11.string().optional()
+var automationCursorSchema = z12.object({
+  timestamp: z12.string(),
+  tieBreaker: z12.string().optional()
 });
-var automationRuntimeStateSchema = z11.object({
+var automationRuntimeStateSchema = z12.object({
   /** The definition revision this state belongs to; a bumped revision re-baselines. */
-  revision: z11.number().optional(),
+  revision: z12.number().optional(),
   /** Enabling establishes a CURRENT-TIME baseline: records older than this never launch. */
-  baselineAt: z11.string().optional(),
+  baselineAt: z12.string().optional(),
   cursor: automationCursorSchema.optional(),
-  frozenHighWatermark: automationCursorSchema.extend({ tieBreaker: z11.string() }).optional(),
-  backlogAfter: automationCursorSchema.extend({ tieBreaker: z11.string() }).optional(),
-  nextCheckAt: z11.string().optional(),
-  lastSuccessAt: z11.string().optional(),
+  frozenHighWatermark: automationCursorSchema.extend({ tieBreaker: z12.string() }).optional(),
+  backlogAfter: automationCursorSchema.extend({ tieBreaker: z12.string() }).optional(),
+  nextCheckAt: z12.string().optional(),
+  lastSuccessAt: z12.string().optional(),
   /** Per-query GitHub ETags, so an unchanged page costs no rate-limit budget. */
-  etags: z11.record(z11.string(), z11.string()).optional(),
-  backoffUntil: z11.string().optional(),
-  consecutiveFailures: z11.number().optional()
+  etags: z12.record(z12.string(), z12.string()).optional(),
+  backoffUntil: z12.string().optional(),
+  consecutiveFailures: z12.number().optional()
 });
-var automationLogResultSchema = z11.enum([
+var automationLogResultSchema = z12.enum([
   "launched",
   "no-match",
   "duplicate",
@@ -1215,80 +1613,91 @@ var automationLogResultSchema = z11.enum([
   "baseline",
   "preview"
 ]);
-var automationLogRecordSchema = z11.object({
-  seq: z11.number(),
-  ts: z11.string(),
-  automationId: z11.string(),
-  revision: z11.number(),
+var automationLogRecordSchema = z12.object({
+  seq: z12.number(),
+  ts: z12.string(),
+  automationId: z12.string(),
+  revision: z12.number(),
   event: automationEventSchema.optional(),
   result: automationLogResultSchema,
-  reason: z11.string().optional(),
-  durationMs: z11.number().optional(),
-  receiptId: z11.string().optional(),
-  runId: z11.string().optional(),
-  githubNumber: z11.number().optional(),
-  githubTitle: z11.string().optional(),
-  githubUrl: z11.string().optional(),
-  rateLimit: z11.object({
-    bucket: z11.enum(["core", "search"]),
-    remaining: z11.number().optional(),
-    resetAt: z11.string().optional()
+  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()
   }).optional()
 });
-var automationCountsSchema = z11.object({
-  matches: z11.number(),
-  launched: z11.number(),
-  duplicates: z11.number(),
-  errors: z11.number()
+var automationCountsSchema = z12.object({
+  matches: z12.number(),
+  launched: z12.number(),
+  duplicates: z12.number(),
+  errors: z12.number()
 });
 var automationListEntrySchema = automationDefinitionSchema.extend({
   state: automationRuntimeStateSchema.optional(),
   latestLog: automationLogRecordSchema.optional(),
   counts: automationCountsSchema
 });
-var automationsResponseSchema = z11.object({
-  available: z11.boolean(),
-  reason: z11.string().optional(),
-  scheduler: z11.object({
-    state: z11.enum(["scheduled", "idle"]),
-    nextDue: z11.string().optional()
+var automationsResponseSchema = z12.object({
+  available: z12.boolean(),
+  reason: z12.string().optional(),
+  scheduler: z12.object({
+    state: z12.enum(["scheduled", "idle"]),
+    nextDue: z12.string().optional()
   }),
-  automations: z11.array(automationListEntrySchema)
+  automations: z12.array(automationListEntrySchema)
 });
-var automationResponseSchema = z11.object({ automation: automationDefinitionSchema });
-var automationDetailResponseSchema = z11.object({
+var automationResponseSchema = z12.object({ automation: automationDefinitionSchema });
+var automationDetailResponseSchema = z12.object({
   automation: automationDefinitionSchema,
   state: automationRuntimeStateSchema.optional(),
   latestLog: automationLogRecordSchema.optional()
 });
-var automationCheckSchema = z11.object({
-  id: z11.string(),
-  automationId: z11.string(),
-  mode: z11.enum(["preview", "execute"]),
-  status: z11.enum(["queued", "running", "complete", "error"]),
-  createdAt: z11.string(),
-  completedAt: z11.string().optional(),
-  matches: z11.number().optional(),
-  truncated: z11.boolean().optional(),
-  error: z11.string().optional()
-});
-var automationCheckQueuedResponseSchema = z11.object({ checkId: z11.string() });
-var automationLogResponseSchema = z11.object({
-  records: z11.array(automationLogRecordSchema)
-});
-var automationRetryResponseSchema = z11.object({
-  receiptId: z11.string(),
-  runId: z11.string()
-});
-var createAutomationInputSchema = automationDefinitionSchema.omit({ id: true, revision: true, createdAt: true, updatedAt: true, enabled: true }).extend({ enable: z11.boolean().optional() });
+var 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 updateAutomationInputSchema = createAutomationInputSchema.omit({ enable: true }).extend({
-  enabled: z11.boolean().optional(),
-  expectedRevision: z11.number()
+  enabled: z12.boolean().optional(),
+  expectedRevision: z12.number()
 });
-var automationCheckInputSchema = z11.object({
-  mode: z11.enum(["preview", "execute"])
+var automationCheckInputSchema = z12.object({
+  mode: z12.enum(["preview", "execute"])
 });
 export {
+  DEFAULT_AGENT_ACCOUNT_ID,
+  MODEL_DISCOVERY_RUNNERS,
+  PROJECT_TAGS_MAX,
+  PROJECT_TAG_MAX_LENGTH,
+  REFERENCE_STATUS_MAX,
+  RUN_HISTORY_PAGE_ITEMS,
+  agentAccountDetailsResponseSchema,
+  agentAccountFileSchema,
+  agentAccountRouteId,
+  agentAccountSelectionSchema,
+  agentAccountStatusResponseSchema,
   agentConfigFileContentSchema,
   agentConfigFileSchema,
   agentConfigFormatSchema,
@@ -1296,6 +1705,10 @@ export {
   agentConfigListingSchema,
   agentConfigScopeSchema,
   agentConfigTrackedSchema,
+  agentProfileResponseSchema,
+  agentProfileSchema,
+  agentProfileSelectionsResponseSchema,
+  agentProfilesResponseSchema,
   apiRunSchema,
   archiveFinishedResponseSchema,
   automationCheckInputSchema,
@@ -1317,6 +1730,7 @@ export {
   automationTaskSchema,
   automationsResponseSchema,
   backendCheckSchema,
+  cancelAutoResumeResponseSchema,
   cancelResponseSchema,
   capabilitiesSchema,
   changedFileSchema,
@@ -1325,6 +1739,7 @@ export {
   checkoutProjectInputSchema,
   configResponseSchema,
   continueResponseSchema,
+  createAgentProfileInputSchema,
   createAutomationInputSchema,
   createPrResponseSchema,
   createRunInputBaseSchema,
@@ -1352,6 +1767,7 @@ export {
   githubPrCheckSchema,
   githubPrMergeStateResponseSchema,
   githubPrMergeStateSchema,
+  githubRefStatusDataSchema,
   githubTimelineEventKindSchema,
   githubTimelineEventSchema,
   groupResponseSchema,
@@ -1364,7 +1780,12 @@ export {
   markAllReadResponseSchema,
   messageInputSchema,
   messageResponseSchema,
+  modelDiscoveryRunnerSchema,
+  openAgentAccountFileInputSchema,
+  openAgentAccountFileResponseSchema,
   openInCliResponseSchema,
+  openProjectInResponseSchema,
+  openProjectInSchema,
   openTargetSchema,
   openTargetsResponseSchema,
   parsedWorkflowSchema,
@@ -1381,7 +1802,10 @@ export {
   providerStatusSchema,
   queuedMessageSchema,
   reclaimWorktreesResponseSchema,
+  referenceStatusSchema,
+  referenceStatusesByProjectSchema,
   registerProjectResponseSchema,
+  removeAgentProfileResponseSchema,
   removeProjectResponseSchema,
   removeQueuedMessageResponseSchema,
   removeTodoResponseSchema,
@@ -1394,18 +1818,30 @@ export {
   runCommitSchema,
   runCommitsResponseSchema,
   runEventSchema,
+  runEventsQuerySchema,
+  runHistoryContextSchema,
+  runHistoryCursorSchema,
+  runHistoryEventSchema,
+  runHistoryPageSchema,
+  runHistoryQuerySchema,
+  runIdParamSchema,
+  runIndexEntrySchema,
   runRecordSchema,
   runStatusSchema,
+  runnerDiscoversModels,
   runnerModelCatalogResponseSchema,
   runnerModelOptionSchema,
   runnerModelsSchema,
   runnerSchema,
+  runsIndexResponseSchema,
   saveWorkflowInputSchema,
   saveWorkflowResponseSchema,
+  selectAgentProfileInputSchema,
   setAgentConfigInputSchema,
   setConfigInputSchema,
   setConfigResponseSchema,
   setWorkspaceConfigInputSchema,
+  setWorkspaceUiStateInputSchema,
   skillSchema,
   skillsUpdateScopeStateSchema,
   skillsUpdateStateSchema,
@@ -1416,6 +1852,7 @@ export {
   stepStatusSchema,
   todoItemSchema,
   uiStateSchema,
+  updateAgentProfileInputSchema,
   updateAutomationInputSchema,
   updateProjectInputSchema,
   updateProjectResponseSchema,