@open-mercato/cezar 0.10.0 → 0.10.1-pr963.1433

package/README.md

@@ -259,9 +259,10 @@ Three words, no jargon — **task**, **skill**, **chain**:
 
 - 📋 **Tasks** are the unit of work. Every task is a **run**: `queued → running →
   review / done / failed / cancelled`, with a live event log, per-step token and
-  cost usage, cancel/delete, and — for anything with a diff — a review gate. Paste
-  screenshots into the task, or send follow-up messages into the live session
-  while it works.
+  cost usage, cancel/delete, and — for anything with a diff — a review gate. Attach
+  screenshots, PDFs, `.txt` or `.md` files to the task (paperclip, ⌘V or drag-drop;
+  the agent gets each one as a real file on disk), or send follow-up messages into
+  the live session while it works.
 - 📖 **Skills** are Markdown playbooks. Drop them in `.ai/skills/` or
   `.ai/cezar/skills/`, or pull them from a shared **team skills repo** (a bare
   git clone cached globally in `~/.cache/cez/`). A workflow step references one by
@@ -314,7 +315,7 @@ Eight views, one browser window, all live over Server-Sent Events (seven until y
 
 | View | What's in it |
 |---|---|
-| **Tasks** | Every task with its status, live event stream (agent text · tool calls · tool results · pasted/generated screenshots), tokens and cost. Continue, cancel, open in terminal (`claude --resume`), review the diff, or push a draft PR. |
+| **Tasks** | Every task with its status, live event stream (agent text · tool calls · tool results · pasted/generated screenshots and file attachments), tokens and cost. Continue, cancel, open in terminal (`claude --resume`), review the diff, or push a draft PR. |
 | **All tasks** | Every *registered project's* tasks in one table, filtered and grouped by tag, project, status or workflow — see [Grouping connected repositories](#grouping-connected-repositories-tags-and-the-all-tasks-page). Appears once a second project is registered. |
 | **Inbox** | **Opt-in** (`CEZ_FOLLOWUPS=1`; hidden by default). Follow-ups an agent left behind (`todos.json`) — one click turns a suggestion into the next task, pre-wired to its suggested skill. Off, agents are never asked to leave follow-ups; each task's own **Notes** handoff journal is unaffected. |
 | **Git** | Branch, working-tree status, diff vs HEAD, recent commits (click one for its inline patch + GitHub link), and the configurable base branch that worktrees fork from and PRs target. |
@@ -595,6 +596,20 @@ cezar is not married to one vendor. Every agent step runs through a single
 On startup cezar probes which CLIs are installed and the cockpit only offers
 the backends it found — install any one of the four and you're operational.
 
+**Models come from your own machine.** The model picker does not ship a list of
+vendor releases that goes stale between cezar versions. For Claude, Codex and
+OpenCode cezar asks the CLI on your host what *it* currently offers (Claude
+Code's `list_models` control request; the Codex app-server's `model/list`;
+`opencode models`) and shows exactly that, in that order — so a model your
+account gained yesterday is selectable today with no cezar release, and one your
+provider retired stops being offered. Discovery is read-only, costs no tokens,
+and is cached briefly in memory. If the CLI is missing, logged out, too old or
+slow, the picker quietly falls back to that runner's built-in entries (`auto`
+plus Claude's tier aliases) and says so in a status row; `pi`, which has no
+host-local catalog yet, always shows its built-in entries. `auto` — send no
+model at all and let the CLI decide — is always available, and a model you
+pinned by hand stays selectable even when it is no longer advertised.
+
 **Pick a backend at three levels** (most specific wins):
 
 1. **Config default** — `"defaultRunner": "codex"` in `.ai/cezar/config.json`.
@@ -624,17 +639,6 @@ steps:
 Parallel variants (×2/×3) of one task share that task's backend — mixing
 happens per task and per step, not inside a variant group.
 
-**Models come from your own machine.** For Codex and OpenCode, the model picker
-is not a list cezar ships — it asks the installed CLI what it can actually run
-(`codex app-server`'s `model/list`, and `opencode models`), caches the answer in
-memory for five minutes, and shows it. A model your provider rolled out
-yesterday is selectable without a cezar release, and one it retired stops being
-offered. Claude Code has no equivalent local catalog, so it keeps a short list
-of tier aliases and pinned versions. `auto` (let the agent decide) is always
-available, including when the CLI is missing, logged out, or slow — discovery
-never blocks the cockpit, and a model you pinned yourself stays selectable even
-if it is absent from the discovered list.
-
 The seam is deliberately small: a backend is one class implementing the
 `AgentRunner` interface (`packages/cezar/src/core/agent-runner.ts`) that turns a prompt into
 a stream of normalized events. Other CLIs — pi, aider, whatever ships next —

package/dist/contract/github.d.ts

@@ -101,6 +101,47 @@ export declare const githubChecksDataSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     reason: z.ZodString;
 }, z.core.$strip>], "available">;
 export type GithubChecksData = z.infer<typeof githubChecksDataSchema>;
+/**
+ * `GET /api/v1/github/search?kind=…&q=…&limit=…` (#730) — issues/PRs in ANY state.
+ *
+ * `GET /api/v1/github` lists the OPEN set only, and the tab's search is an in-memory filter over
+ * exactly that payload, so a closed or merged item is not "outside the fetched window" — it was
+ * never fetched, and nothing the user types can reach it. This is the cross-state lookup the tab
+ * falls back to.
+ *
+ * Not a discriminated union, like `githubDataSchema` and unlike `githubChecksDataSchema`: the
+ * driver always answers the full record and merely flips `available`, so an unavailable payload
+ * still carries `items: []`.
+ */
+export declare const githubSearchDataSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            issue: "issue";
+            pr: "pr";
+        }>;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        author: z.ZodString;
+        createdAt: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        body: z.ZodString;
+        url: z.ZodString;
+        comments: z.ZodNumber;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
+        additions: z.ZodOptional<z.ZodNumber>;
+        deletions: z.ZodOptional<z.ZodNumber>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+    }, z.core.$strip>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    labelColors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type GithubSearchData = z.infer<typeof githubSearchDataSchema>;
 /**
  * Where a referenced PR or issue STANDS — the vocabulary a task's tracker chip paints.
  *
@@ -182,6 +223,7 @@ export declare const githubRefStatusDataSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         ready: "ready";
         "review-required": "review-required";
     }>>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     recheckAfterMs: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     available: z.ZodLiteral<false>;

package/dist/contract/index.js

@@ -162,6 +162,19 @@ var githubChecksDataSchema = z3.discriminatedUnion("available", [
     reason: z3.string()
   })
 ]);
+var githubSearchDataSchema = z3.object({
+  available: z3.boolean(),
+  /** Why it could not search (`gh` missing, no remote, rate-limited…). A hint, never an error. */
+  reason: z3.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),
+  /** The hit list filled the server's cap; there may be more matches on the forge. */
+  truncated: z3.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()
+});
 var referenceStatusSchema = z3.enum([
   "draft",
   "review-required",
@@ -182,6 +195,26 @@ var githubRefStatusDataSchema = z3.discriminatedUnion("available", [
     available: z3.literal(true),
     prs: z3.record(z3.number(), referenceStatusSchema),
     issues: z3.record(z3.number(), referenceStatusSchema),
+    /**
+     * The pull request numbers that do NOT merge cleanly into their base right now.
+     *
+     * A second list rather than a twelfth status, because a conflict is a different AXIS from the
+     * one `referenceStatusSchema` ranks. That enum answers *whose move is it*, and it answers with
+     * one word; mergeability is an independent fact that can be true alongside any of them — a PR
+     * can be green, approved and conflicting at the same time, and folding the two together would
+     * force the cockpit to pick which of two true things to say. Kept apart, it paints a second
+     * chip next to the first and says both.
+     *
+     * It rides the same GraphQL node the statuses come from (`mergeable`), so unlike
+     * `githubPrMergeStateResponseSchema` — the full per-PR probe, blockers and all — it costs no
+     * extra request for the batch.
+     *
+     * Optional on the wire, and its absence means *nothing is known about mergeability*, never
+     * *no conflicts*: a server from before this field simply omits it. Only OPEN pull requests are
+     * 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(),
     recheckAfterMs: recheckAfterMsSchema
   }),
   z3.object({
@@ -444,7 +477,8 @@ var diffStatSchema = z5.object({
 var queuedMessageSchema = z5.object({
   id: z5.string(),
   text: z5.string(),
-  /** `/api/v1/runs/:id/images/…` URLs — attachments are persisted, never inlined. */
+  /** `/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()
 });
@@ -467,7 +501,8 @@ var runRecordSchema = z5.object({
   /** 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(),
-  /** URLs of images attached to the initial task prompt (#image-display). */
+  /** 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(),
   /** Normalized provider/model identity used for attribution and reproducible replay. */
@@ -560,6 +595,17 @@ var runRecordSchema = z5.object({
   peakProcCount: z5.number().optional(),
   archived: z5.boolean(),
   archivedAt: z5.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(),
+  /** 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(),
   /** 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
@@ -742,10 +788,33 @@ var groupResponseSchema = z5.object({
 var pickVariantResponseSchema = z5.object({
   winner: runRecordSchema.optional()
 });
-var imageInputSchema = z5.object({
-  mediaType: z5.string().regex(/^image\//),
+var FILE_ATTACHMENT_MEDIA_TYPES = [
+  "text/plain",
+  "text/markdown",
+  "text/x-markdown",
+  "application/pdf"
+];
+function isImageMediaType(mediaType) {
+  return /^image\//.test(mediaType);
+}
+function isAttachmentMediaType(mediaType) {
+  return isImageMediaType(mediaType) || FILE_ATTACHMENT_MEDIA_TYPES.includes(mediaType);
+}
+function attachmentExtension(mediaType) {
+  return /png/.test(mediaType) ? "png" : /jpe?g/.test(mediaType) ? "jpg" : /webp/.test(mediaType) ? "webp" : /gif/.test(mediaType) ? "gif" : mediaType === "application/pdf" ? "pdf" : mediaType === "text/plain" ? "txt" : mediaType === "text/markdown" || mediaType === "text/x-markdown" ? "md" : "img";
+}
+var IMAGE_ATTACHMENT_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "webp", "gif", "img"]);
+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, {
+    message: "unsupported attachment type \u2014 images, plain text, markdown and PDF only"
+  }),
   data: z5.string().min(1).max(7e6)
 });
+var imageInputSchema = attachmentInputSchema;
 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
@@ -770,8 +839,10 @@ var createRunInputBaseSchema = z5.object({
   /** 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),
-  /** Screenshots pasted into the new-task form; delivered with the first agent step. */
-  images: z5.array(imageInputSchema).max(4).optional(),
+  /** 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(),
   /** 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()
@@ -782,9 +853,9 @@ var createRunInputSchema = createRunInputBaseSchema.refine(
 );
 var messageInputSchema = z5.object({
   text: z5.string().max(1e5).default(""),
-  images: z5.array(imageInputSchema).max(4).default([])
+  images: z5.array(attachmentInputSchema).max(4).default([])
 }).refine((m) => m.text.trim().length > 0 || m.images.length > 0, {
-  message: "message needs text or at least one image"
+  message: "message needs text or at least one attachment"
 });
 var patchRunInputSchema = z5.object({
   title: z5.string().trim().min(1).max(300).optional(),
@@ -1082,7 +1153,11 @@ var taskTableUiStateSchema = z8.looseObject({
   expandedColumns: z8.record(z8.string(), z8.boolean()).optional()
 });
 var uiStateSchema = z8.looseObject({
-  lastTask: z8.object({ source: z8.enum(["workflow", "skill"]), ref: z8.string() }).optional(),
+  /** What the last started run used. `null` is a VALUE, not an absence: it records a run that
+   *  chose neither a skill nor a workflow (the plain built-in `quick-task`), which the composer
+   *  can now express since the source picker grew an empty state. Absent still means "no
+   *  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(),
   /** 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(),
@@ -1284,7 +1359,7 @@ 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 modelDiscoveryRunnerSchema = z8.enum(["claude", "codex", "opencode"]);
 var MODEL_DISCOVERY_RUNNERS = modelDiscoveryRunnerSchema.options;
 function runnerDiscoversModels(runner) {
   return MODEL_DISCOVERY_RUNNERS.includes(runner);
@@ -1688,6 +1763,7 @@ var automationCheckInputSchema = z12.object({
 });
 export {
   DEFAULT_AGENT_ACCOUNT_ID,
+  FILE_ATTACHMENT_MEDIA_TYPES,
   MODEL_DISCOVERY_RUNNERS,
   PROJECT_TAGS_MAX,
   PROJECT_TAG_MAX_LENGTH,
@@ -1711,6 +1787,8 @@ export {
   agentProfilesResponseSchema,
   apiRunSchema,
   archiveFinishedResponseSchema,
+  attachmentExtension,
+  attachmentInputSchema,
   automationCheckInputSchema,
   automationCheckQueuedResponseSchema,
   automationCheckSchema,
@@ -1768,6 +1846,7 @@ export {
   githubPrMergeStateResponseSchema,
   githubPrMergeStateSchema,
   githubRefStatusDataSchema,
+  githubSearchDataSchema,
   githubTimelineEventKindSchema,
   githubTimelineEventSchema,
   groupResponseSchema,
@@ -1775,6 +1854,9 @@ export {
   healthResponseSchema,
   imageInputSchema,
   importableSkillSchema,
+  isAttachmentMediaType,
+  isImageAttachmentName,
+  isImageMediaType,
   launchKeyResponseSchema,
   logEntrySchema,
   markAllReadResponseSchema,

package/dist/contract/runs.d.ts

@@ -207,6 +207,8 @@ export declare const runRecordSchema: z.ZodObject<{
     peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodBoolean;
     archivedAt: z.ZodOptional<z.ZodString>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+    pinnedAt: z.ZodOptional<z.ZodString>;
     seenAt: z.ZodOptional<z.ZodString>;
     currentStepId: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
@@ -374,6 +376,8 @@ export declare const apiRunSchema: z.ZodObject<{
     peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodBoolean;
     archivedAt: z.ZodOptional<z.ZodString>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+    pinnedAt: z.ZodOptional<z.ZodString>;
     seenAt: z.ZodOptional<z.ZodString>;
     currentStepId: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
@@ -739,6 +743,8 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
     peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodBoolean;
     archivedAt: z.ZodOptional<z.ZodString>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+    pinnedAt: z.ZodOptional<z.ZodString>;
     seenAt: z.ZodOptional<z.ZodString>;
     currentStepId: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
@@ -900,6 +906,8 @@ export declare const createRunResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
         peakProcCount: z.ZodOptional<z.ZodNumber>;
         archived: z.ZodBoolean;
         archivedAt: z.ZodOptional<z.ZodString>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+        pinnedAt: z.ZodOptional<z.ZodString>;
         seenAt: z.ZodOptional<z.ZodString>;
         currentStepId: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
@@ -1268,6 +1276,8 @@ export declare const pickVariantResponseSchema: z.ZodObject<{
         peakProcCount: z.ZodOptional<z.ZodNumber>;
         archived: z.ZodBoolean;
         archivedAt: z.ZodOptional<z.ZodString>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+        pinnedAt: z.ZodOptional<z.ZodString>;
         seenAt: z.ZodOptional<z.ZodString>;
         currentStepId: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
@@ -1342,12 +1352,56 @@ export declare const pickVariantResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PickVariantResponse = z.infer<typeof pickVariantResponseSchema>;
-/** An inline image, base64 — ≤4 per request, ~5 MB each once decoded. */
+/**
+ * Non-image attachment types the composer may send (#950). Deliberately an allowlist and
+ * deliberately short: cezar serves these files back from the cockpit's own origin, so every entry
+ * here is one more thing that must be safe to hand a browser. `image/*` stays a regex — narrowing
+ * what the route has always accepted would be the breaking half of this change.
+ *
+ * `text/x-markdown` is the spelling some browsers still report for a `.md`.
+ */
+export declare const FILE_ATTACHMENT_MEDIA_TYPES: readonly ['text/plain', 'text/markdown', 'text/x-markdown', 'application/pdf'];
+/** Does this media type travel as an inline image block the model can look at? */
+export declare function isImageMediaType(mediaType: string): boolean;
+/** Is this something the composer may attach at all — an image, or one of the file types above? */
+export declare function isAttachmentMediaType(mediaType: string): boolean;
+/**
+ * The on-disk extension for an attachment, derived from its media type ALONE — the user's own
+ * filename never reaches the wire, and therefore never reaches a path. `img` is the pre-existing
+ * catch-all for an image type cezar does not name (an SVG, a BMP), kept so those files land where
+ * they always did.
+ */
+export declare function attachmentExtension(mediaType: string): string;
+/**
+ * Does a persisted attachment name (`pasted-3.pdf`, `screenshot-1.png`) refer to an image?
+ *
+ * The one predicate every reader branches on — the engine deciding whether to re-encode a file as
+ * an image block, and the cockpit deciding between a thumbnail and a named chip. Branch on the
+ * NAME, never on the list an entry came from: images and files share one list and one numbering
+ * space on disk, and that is what keeps the orphan sweep, the restart re-read and the per-stack
+ * cap on a single code path.
+ */
+export declare function isImageAttachmentName(name: string): boolean;
+/**
+ * One inline attachment, base64 — ≤4 per request, ~5 MB each once decoded.
+ *
+ * An image rides along as a block the model can view; a file (#950) is written to the run's
+ * attachment folder and reaches the agent as a PATH only, which is the form its file tools want,
+ * the only form that survives the codex/opencode backends (they drop image blocks before the
+ * model sees them), and the one that keeps a multi-megabyte PDF out of the prompt bounds.
+ */
+export declare const attachmentInputSchema: z.ZodObject<{
+    mediaType: z.ZodString;
+    data: z.ZodString;
+}, z.core.$strip>;
+export type AttachmentInput = z.input<typeof attachmentInputSchema>;
+/** @deprecated Attachments are no longer images only — use `attachmentInputSchema`. Kept because
+ *  the `images` key it validates is the wire contract and did not change name. */
 export declare const imageInputSchema: z.ZodObject<{
     mediaType: z.ZodString;
     data: z.ZodString;
 }, z.core.$strip>;
-export type ImageInput = z.input<typeof imageInputSchema>;
+export type ImageInput = AttachmentInput;
 /**
  * The KEYS of `POST /runs`' body, before the XOR refinement that `createRunInputSchema` adds.
  *
@@ -1448,7 +1502,7 @@ export declare const createRunInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type CreateRunInput = z.input<typeof createRunInputSchema>;
 /**
- * `POST /runs/:id/messages` — text and/or pasted screenshots for a live session. Both keys have
+ * `POST /runs/:id/messages` — text and/or pasted attachments for a live session. Both keys have
  * server-side defaults, so an omitted `text` is `''` and an omitted `images` is `[]`; the refine
  * is what rejects a message that is empty in both.
  */

package/dist/contract/skills.d.ts

@@ -156,6 +156,8 @@ export declare const startTodoResponseSchema: z.ZodObject<{
         peakProcCount: z.ZodOptional<z.ZodNumber>;
         archived: z.ZodBoolean;
         archivedAt: z.ZodOptional<z.ZodString>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+        pinnedAt: z.ZodOptional<z.ZodString>;
         seenAt: z.ZodOptional<z.ZodString>;
         currentStepId: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;

package/dist/contract/workspace.d.ts

@@ -110,13 +110,13 @@ export type SetWorkspaceConfigInput = z.infer<typeof setWorkspaceConfigInputSche
  * listed it, which made it wider than the route.
  */
 export declare const uiStateSchema: z.ZodObject<{
-    lastTask: z.ZodOptional<z.ZodObject<{
+    lastTask: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         source: z.ZodEnum<{
             skill: "skill";
             workflow: "workflow";
         }>;
         ref: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     recentSources: z.ZodOptional<z.ZodArray<z.ZodObject<{
         source: z.ZodEnum<{
             skill: "skill";
@@ -498,12 +498,14 @@ export declare const providerConnectResponseSchema: z.ZodDiscriminatedUnion<[z.Z
 }, z.core.$strip>], "opened">;
 export type ProviderConnectResponse = z.infer<typeof providerConnectResponseSchema>;
 /**
- * The runners whose model list is discovered from the host rather than hard-coded: Codex
- * through its app-server protocol, OpenCode through its own `models` listing (#794). Claude has
- * no equivalent local source, so its picker keeps static presets and `GET /api/v1/models`
- * rejects it. One definition, used by the route's query validator and by the cockpit's picker.
+ * The runners whose model list is discovered from the host rather than hard-coded: Codex through
+ * its app-server protocol, OpenCode through its own `models` listing (#794), Claude through the
+ * CLI's `list_models` control request (#784). A runner absent here has no discovery path and
+ * 400s, so the client compiles against exactly what the route accepts. One definition, used by
+ * the route's query validator and by the cockpit's picker.
  */
 export declare const modelDiscoveryRunnerSchema: z.ZodEnum<{
+    claude: "claude";
     codex: "codex";
     opencode: "opencode";
 }>;
@@ -517,9 +519,9 @@ export declare const runnerModelOptionSchema: z.ZodObject<{
     description: z.ZodString;
 }, z.core.$strip>;
 export type RunnerModelOption = z.infer<typeof runnerModelOptionSchema>;
-/** `GET /api/v1/models?runner=codex|opencode` — the models discovered from that runner's own
- *  host installation, plus how fresh the answer is. Never an error: an unavailable CLI degrades
- *  to `source: 'unavailable'` with a `reason`. Claude has no host-local catalog and is rejected. */
+/** `GET /api/v1/models?runner=claude|codex|opencode` — the models discovered from that runner's
+ *  own host installation, plus how fresh the answer is. Never an error: an unavailable CLI
+ *  degrades to `source: 'unavailable'` with a `reason`. */
 export declare const runnerModelCatalogResponseSchema: z.ZodObject<{
     runner: z.ZodEnum<{
         claude: "claude";

package/dist/core/ask.d.ts

@@ -49,7 +49,9 @@ export interface AskParseIssue {
     message: string;
 }
 /** The diagnostic parse result used at turn-end. The compatibility wrapper
- * below deliberately keeps returning `AskRequest | null`. */
+ * below deliberately keeps returning `AskRequest | null`. `repaired` marks a
+ * card that only exists because the payload's missing closers were appended
+ * (#936) — callers surface it as a note rather than claiming a clean parse. */
 export type AskMarkerParseResult = {
     kind: 'none';
 } | {
@@ -62,6 +64,7 @@ export type AskMarkerParseResult = {
     kind: 'valid';
     request: AskRequest;
     normalized: boolean;
+    repaired?: boolean;
 };
 /**
  * Parse a value into a validated `AskRequest`, or `null` when it does not match
@@ -79,9 +82,12 @@ export declare function parseAskRequest(value: unknown): AskRequest | null;
  */
 export declare const ASK_MARKER_RE: RegExp;
 /**
- * Parse a trailing marker with an actionable result for diagnostics. A
- * parseable near-valid request gets one bounded normalization pass; structural
- * violations remain rejected so the raw fallback stays readable.
+ * Parse a trailing marker with an actionable result for diagnostics. Two
+ * bounded forgiveness layers sit under the schema, and neither loosens it: a
+ * payload that fails `JSON.parse` only for missing closers is repaired
+ * (`closeUnbalancedJson`, #936), then a parseable near-valid request gets one
+ * normalization pass (`normalizeAskRequest`). Structural violations remain
+ * rejected so the raw fallback stays readable.
  */
 export declare function parseAskMarkerResult(turnText: string): AskMarkerParseResult;
 /**
@@ -101,5 +107,10 @@ export declare function parseAskMarker(turnText: string): AskRequest | null;
  * the marker across events — then it stays visible; detection on the assembled
  * turn text is unaffected (same best-effort caveat as the `CEZ:DONE` /
  * `CEZ:MONITORING` strippers).
+ *
+ * The strip runs from the `CEZ:ASK` keyword to end-of-text rather than to a
+ * trailing `}`: a repaired payload (#936) may end on `]`, or on the last
+ * character before the closers this module appended, and half a marker left
+ * under a rendered card is protocol noise the card already replaced.
  */
 export declare function stripAskMarker(text: string): string;