@bendyline/gezel 1.0.5 → 1.0.7

package/dist/markdown/index.js

@@ -1,5 +1,5 @@
 // src/schemas/craftbook.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/roles/tier.ts
 var MODEL_TIER_ORDER = [
@@ -34,7 +34,9 @@ var NamedScriptCapabilitySchema = z2.enum([
   "tasks.read",
   "tasks.write",
   "memory.read",
-  "memory.write"
+  "memory.write",
+  "index.read",
+  "index.refresh"
 ]);
 var CredentialCapabilitySchema = z2.string().regex(
   /^credential:[a-zA-Z][\w.:-]*$/,
@@ -428,7 +430,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
   z3.object({
     kind: z3.literal("totalMinBytes"),
     files: z3.array(z3.string().min(1)).min(1),
-    bytes: z3.number().int().positive()
+    bytes: z3.number().int().positive(),
+    artifact: z3.boolean().optional()
   }),
   /**
    * At least `min` workspace files with one of `ext` exist (e.g. ≥3 images).
@@ -445,13 +448,15 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     ext: z3.array(z3.string().min(1)).min(1),
     min: z3.number().int().positive(),
     dir: z3.string().optional(),
-    verifyImageBytes: z3.boolean().optional()
+    verifyImageBytes: z3.boolean().optional(),
+    artifact: z3.boolean().optional()
   }),
   /** Inline `<style>` + linked `.css` in `file` (default index.html) clears `bytes`. */
   z3.object({
     kind: z3.literal("cssMinBytes"),
     bytes: z3.number().int().positive(),
-    file: z3.string().optional()
+    file: z3.string().optional(),
+    artifact: z3.boolean().optional()
   }),
   /** A named content sniff passes on `file` (workspace, or the artifacts drawer when `artifact`). */
   z3.object({
@@ -466,7 +471,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     file: z3.string().min(1),
     path: z3.string().min(1),
     value: GateJsonScalarSchema,
-    label: z3.string().min(1).optional()
+    label: z3.string().min(1).optional(),
+    artifact: z3.boolean().optional()
   }),
   /** A CSV file has the expected header/row shape and optional picklist values. */
   z3.object({
@@ -476,7 +482,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     exactColumns: z3.array(z3.string().min(1)).min(1).optional(),
     minRows: z3.number().int().nonnegative().optional(),
     consistentColumns: z3.boolean().optional(),
-    allowedValues: z3.record(z3.string(), z3.array(z3.string().min(1)).min(1)).optional()
+    allowedValues: z3.record(z3.string(), z3.array(z3.string().min(1)).min(1)).optional(),
+    artifact: z3.boolean().optional()
   }),
   /** `file` matches `pattern` (regex), in the workspace or the artifacts drawer when `artifact`. */
   z3.object({
@@ -511,7 +518,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
         label: z3.string().min(1).optional()
       })
     ).min(1),
-    flags: z3.string().optional()
+    flags: z3.string().optional(),
+    artifact: z3.boolean().optional()
   }),
   /**
    * Every inline `<script>` body in `file` (default index.html) parses as
@@ -523,7 +531,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
    */
   z3.object({
     kind: z3.literal("jsParses"),
-    file: z3.string().optional()
+    file: z3.string().optional(),
+    artifact: z3.boolean().optional()
   }),
   /**
    * An in-process, zero-spawn static gate for an HTML deliverable: the document
@@ -534,7 +543,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
    */
   z3.object({
     kind: z3.literal("htmlLint"),
-    file: z3.string().min(1)
+    file: z3.string().min(1),
+    artifact: z3.boolean().optional()
   }),
   /**
    * Named `node:` imports in `file` resolve to real builtin exports, and a
@@ -547,7 +557,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
    */
   z3.object({
     kind: z3.literal("esmImports"),
-    file: z3.string().min(1)
+    file: z3.string().min(1),
+    artifact: z3.boolean().optional()
   }),
   /**
    * `file` parses as source code. For `.ts/.tsx/.js/.mjs/.cjs/.jsx` the
@@ -559,7 +570,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
    */
   z3.object({
     kind: z3.literal("sourceParses"),
-    file: z3.string().min(1)
+    file: z3.string().min(1),
+    artifact: z3.boolean().optional()
   }),
   /**
    * The first Markdown table in `file` has the required header set and
@@ -591,6 +603,18 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     minRows: z3.number().int().nonnegative().optional(),
     uniqueBy: z3.string().optional(),
     format: z3.enum(["json", "csv", "auto"]).optional(),
+    /**
+     * Accept fields beyond `fields` (default false — an exact field set).
+     *
+     * Strict is right for a locked-schema data deliverable, where an
+     * unexpected key means the writer misunderstood the contract. It is
+     * wrong for a REGISTER — a findings list, a drift list — where extra
+     * context (a cwe, a title, an id) is a better deliverable, not a
+     * broken one, and rejecting it grades schema-guessing instead of the
+     * work. The underlying `recordSchema` check has always supported this;
+     * only the declarative gate could not say it.
+     */
+    allowExtraFields: z3.boolean().optional(),
     artifact: z3.boolean().optional()
   }),
   /**
@@ -601,6 +625,12 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
    * dependency-free files can run (node built-ins ok; the sandbox has no
    * npm tree): a `node:test`/`assert` file exits nonzero on failure,
    * which is exactly the contract.
+   *
+   * Alone among the file-reading checks this takes no `artifact` flag: it
+   * does not read through the swappable gate reader at all, it hands the
+   * path to the sandbox executor, which resolves against the workspace.
+   * Accepting the flag would parse fine and then silently execute the
+   * wrong tree — the exact failure mode the flag exists to prevent.
    */
   z3.object({
     kind: z3.literal("nodeRuns"),
@@ -630,17 +660,51 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
    * `sourcePath` is non-empty, an exact successful `read_file` of that path
    * qualifies; otherwise one of `tools` must have completed against an
    * external source. The runtime supplies the live tool-call evidence.
+   * `externalOptional` softens only the no-sourcePath branch: authored local
+   * sources remain mandatory, while a topic-only workflow may recommend web
+   * research without becoming impossible under an offline security policy.
    */
   z3.object({
     kind: z3.literal("researchEvidence"),
     sourcePath: z3.string().optional(),
     tools: z3.array(z3.string().min(1)).min(1),
-    minSuccessful: z3.number().int().positive().optional()
+    minSuccessful: z3.number().int().positive().optional(),
+    externalOptional: z3.boolean().optional()
+  }),
+  /**
+   * Require a real command run during this activation, verified against the
+   * service-written run receipts (`workspace.script.run` / `workspace.npx.run`
+   * history events — the model cannot forge them, and the gate never
+   * executes anything itself). Exactly one of `script` (a package.json
+   * script name) or `bin` (an npx binary) names the command; `args` must
+   * match the receipt's extra args exactly (default: argless). `expect`
+   * judges the LATEST matching run's exit code — `'fail'` is the
+   * red-before-green half of a repro-first fix (the failing test must
+   * actually fail), `'pass'` is the suite-green proof after it. A timed-out
+   * run satisfies neither. On a drafting task the project's commands run
+   * against the unmodified tree, so `onDraft: 'defer'` (the default)
+   * approves with an explicit "execution deferred until Apply" note instead
+   * of demanding a receipt that would be a lie; `'require'` hard-blocks
+   * instead. Books standardize on the argless canonical invocation because
+   * command approvals pin one invocation hash per script name.
+   */
+  z3.object({
+    kind: z3.literal("commandEvidence"),
+    script: z3.string().min(1).optional(),
+    bin: z3.string().min(1).optional(),
+    args: z3.array(z3.string()).optional(),
+    expect: z3.enum(["pass", "fail"]),
+    minRuns: z3.number().int().positive().optional(),
+    onDraft: z3.enum(["defer", "require"]).optional(),
+    label: z3.string().min(1).optional()
   }),
   /**
    * A PR-review coverage ledger must name every changed path materialized in
-   * a connector corpus. The ledger is workspace JSON (`reviewedFiles` by
-   * default); the source records live in the read-only artifacts drawer and
+   * a connector corpus. The ledger is JSON (`reviewedFiles` by default) in
+   * the workspace, or in the artifacts drawer when `artifact` — a review of
+   * a read-only checkout can only write the drawer, so omitting the flag
+   * here made the whole Pull Request Review book unsatisfiable on any
+   * writes-off project. The source records always live in the drawer and
    * carry their authoritative path in frontmatter. This prevents a polished
    * report from passing after only the first context-sized prefix was read.
    */
@@ -649,7 +713,49 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     file: z3.string().min(1),
     corpusDir: z3.string().min(1),
     reviewedField: z3.string().min(1).optional(),
-    recordField: z3.string().min(1).optional()
+    recordField: z3.string().min(1).optional(),
+    artifact: z3.boolean().optional(),
+    /**
+     * JSON array of the exact changed paths THIS ledger must cover, as a
+     * string — narrows the check from the whole corpus to one slice of it.
+     * Written for declarative fanout: a child reviewing batch 2 of 3 gets
+     * `"{{paths}}"` from its per-item context and is gated on its own 25
+     * files, not on the 68 nobody handed it. Without this a batch child
+     * can never pass its own gate, and coverage can only be enforced
+     * after a merge — far downstream of the child that under-delivered.
+     *
+     * Fails closed on anything that is not a JSON array of strings,
+     * including an uninterpolated `{{…}}` token: a mis-scoped coverage
+     * check that silently widens back to the full corpus would reject
+     * every child forever with a verdict none of them can act on.
+     */
+    expectPaths: z3.string().min(1).optional()
+  }),
+  /**
+   * A fanout-input batch file must reproduce a connector corpus manifest's own
+   * batch array exactly — same count, same ordinals, same paths, in order.
+   *
+   * The upstream sibling of {@link corpusCoverage}: that check proves the work
+   * covered the corpus, this one proves the *plan* did. A batch file is the
+   * spawn host's `overFile`, so a batch dropped here is never reviewed by
+   * anyone and never appears in any coverage ledger. `json-valid` + `minBytes`
+   * cannot see it: a batch array truncated at the model's output cap is still
+   * syntactically perfect JSON. Wild-caught on a 509-file PR whose scope step
+   * published 10 of 21 batches — 259 files silently out of scope, and the run
+   * then deadlocked eight attempts deep in the downstream merge gate, which is
+   * the wrong place to learn it and the one place that cannot fix it.
+   */
+  z3.object({
+    kind: z3.literal("corpusBatches"),
+    file: z3.string().min(1),
+    corpusDir: z3.string().min(1),
+    /** Filename suffix identifying the manifest inside the corpus. */
+    manifestSuffix: z3.string().min(1).optional(),
+    /** Manifest field holding the authoritative batch array. */
+    itemsField: z3.string().min(1).optional(),
+    /** Manifest field holding the total item count the batches must cover. */
+    totalField: z3.string().min(1).optional(),
+    artifact: z3.boolean().optional()
   }),
   /**
    * The H1 slide titles in `file` must match the numbered slide headings in
@@ -662,7 +768,8 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     file: z3.string().min(1),
     outlineFile: z3.string().min(1),
     /** Read outlineFile from artifacts while file uses the check's primary surface. */
-    outlineArtifact: z3.boolean().optional()
+    outlineArtifact: z3.boolean().optional(),
+    artifact: z3.boolean().optional()
   }),
   /**
    * Named facts in `file` must come from authorized sources: each fact
@@ -881,16 +988,39 @@ var HookResultSchema = z4.object({
   message: z4.string().optional()
 });
 
+// src/schemas/retrieval.ts
+import { z as z5 } from "zod";
+var RETRIEVAL_MODES = ["off", "lean", "balanced", "deep"];
+var RetrievalModeSchema = z5.enum(RETRIEVAL_MODES);
+var RETRIEVAL_SOURCES = [
+  "workspace",
+  "artifacts",
+  "project-memory",
+  "gezel-memory",
+  "shared",
+  // Installed knowledge catalogs (read-only reference corpora — .gezk).
+  // Scoped by the user's registry + the project's knowledgeCatalogs policy.
+  "knowledge"
+];
+var RetrievalSourceSchema = z5.enum(RETRIEVAL_SOURCES);
+var RetrievalPolicySchema = z5.object({
+  mode: RetrievalModeSchema,
+  /** Hard prompt budget after the mode preset and context-window clamp. */
+  maxTokens: z5.number().int().min(0).max(16e3).optional(),
+  /** Absent means every corpus appropriate to the current session. */
+  sources: z5.array(RetrievalSourceSchema).min(1).optional()
+});
+
 // src/schemas/craftbook.ts
-var CraftbookBranchSchema = z5.object({
+var CraftbookBranchSchema = z6.object({
   when: ScriptOutputPredicateSchema,
-  goto: z5.string()
+  goto: z6.string()
 });
-var AdvanceWhenSchema = z5.object({
+var AdvanceWhenSchema = z6.object({
   /** Workspace-relative deliverable whose presence signals "this step is done". */
-  file: z5.string().min(1),
+  file: z6.string().min(1),
   /** Liveness floor in bytes (guards against an empty/stub file). Default 1. */
-  minBytes: z5.number().int().positive().optional(),
+  minBytes: z6.number().int().positive().optional(),
   /**
    * Named content check the runtime runs before advancing. `html-complete`
    * = a non-truncated HTML doc (balanced `<script>` tags + a closing
@@ -911,7 +1041,7 @@ var AdvanceWhenSchema = z5.object({
    * `insert_at_marker` targeting `file` this turn). The `sniff`/`minBytes`
    * floor still applies on top. Absent → legacy "exists is enough".
    */
-  requireChange: z5.boolean().optional(),
+  requireChange: z6.boolean().optional(),
   /**
    * Resolve `file` against the project's ARTIFACTS drawer
    * (`read_artifact` / `write_artifact`) instead of the shipped workspace.
@@ -921,28 +1051,28 @@ var AdvanceWhenSchema = z5.object({
    * deliverable is gated for size/shape exactly like a workspace one.
    * Absent → workspace (the default).
    */
-  artifact: z5.boolean().optional(),
+  artifact: z6.boolean().optional(),
   /** Step to activate on the signal. Defaults to `next`; must resolve like `next`. */
-  goto: z5.string().optional()
+  goto: z6.string().optional()
 });
-var CraftbookStepInputSchema = z5.object({
+var CraftbookStepInputSchema = z6.object({
   /** Path relative to the selected drawer's root. */
-  file: z5.string().min(1).describe("Path relative to the selected drawer root."),
+  file: z6.string().min(1).describe("Path relative to the selected drawer root."),
   /** Read from the artifacts drawer instead of the project workspace. */
-  artifact: z5.boolean().optional().describe("True for the artifacts drawer; false/omitted for the project workspace.")
+  artifact: z6.boolean().optional().describe("True for the artifacts drawer; false/omitted for the project workspace.")
 });
-var ModelTierSchema = z5.enum(MODEL_TIER_ORDER);
-var CraftbookStepSchema = z5.object({
-  id: z5.string().min(1),
-  name: z5.string().min(1),
-  description: z5.string().optional(),
+var ModelTierSchema = z6.enum(MODEL_TIER_ORDER);
+var CraftbookStepSchema = z6.object({
+  id: z6.string().min(1),
+  name: z6.string().min(1),
+  description: z6.string().optional(),
   /**
    * Per-step prompt body. In bundled/local catalog form, this is loaded
    * from the per-step `prompt.md` file (when the version manifest carries
    * a separate file) and inlined at resolution time.
    */
-  prompt: z5.string().optional(),
-  suggestedGezelId: z5.string().optional(),
+  prompt: z6.string().optional(),
+  suggestedGezelId: z6.string().optional(),
   /**
    * Free-form role hint ("reviewer", "developer", "designer"). When set
    * and `suggestedGezelId` / `assignee` are both absent at step
@@ -953,7 +1083,7 @@ var CraftbookStepSchema = z5.object({
    * specific gezel id. Override by setting `assignee` or
    * `suggestedGezelId` at task create time.
    */
-  suggestedRole: z5.string().optional(),
+  suggestedRole: z6.string().optional(),
   /**
    * Minimum model tier to run this step unsupervised. Overrides the
    * `suggestedRole`'s registry floor (roles/registry.ts) when set;
@@ -962,6 +1092,8 @@ var CraftbookStepSchema = z5.object({
    * that clears the floor runs the step.
    */
   capabilityFloor: ModelTierSchema.optional(),
+  /** Per-phase indexed-context policy; overrides gezel and install defaults. */
+  retrieval: RetrievalPolicySchema.optional(),
   assignee: TaskAssigneeSchema.optional(),
   /** Setup scripts, run in order when the step activates. Single ref = legacy shape. */
   onEnter: ScriptRefListSchema.optional(),
@@ -972,16 +1104,16 @@ var CraftbookStepSchema = z5.object({
    */
   onExit: ScriptRefListSchema.optional(),
   /** Required file inputs for this step, in the order they should be opened. */
-  consumes: z5.array(CraftbookStepInputSchema).min(1).optional().describe(
+  consumes: z6.array(CraftbookStepInputSchema).min(1).optional().describe(
     "Files this step must open before working. Artifact inputs also require an explicit `read_artifact` call in the step prompt."
   ),
   /** See {@link AdvanceWhenSchema}. */
   advanceWhen: AdvanceWhenSchema.optional(),
   /** The end-of-step decision. See {@link StepGateSchema} (current) / {@link GateSpecSchema} (legacy). */
   gate: StepGateUnionSchema.optional(),
-  next: z5.string().optional(),
-  branches: z5.array(CraftbookBranchSchema).optional(),
-  terminal: z5.boolean().optional(),
+  next: z6.string().optional(),
+  branches: z6.array(CraftbookBranchSchema).optional(),
+  terminal: z6.boolean().optional(),
   /**
    * Marks the parent step that triggers a declarative per-item fanout
    * (see {@link CraftbookSpawnSchema}). When this step activates on a
@@ -989,19 +1121,19 @@ var CraftbookStepSchema = z5.object({
    * JSON array on its declared surface and spawns one child task per item — no model
    * tool call. Inert unless the craftbook also declares `spawn`.
    */
-  spawnFanout: z5.boolean().optional()
+  spawnFanout: z6.boolean().optional()
 });
-var CraftbookSpawnSchema = z5.object({
+var CraftbookSpawnSchema = z6.object({
   /** Surface-relative JSON file the parent produces; its array drives the fanout. */
-  overFile: z5.string().min(1),
+  overFile: z6.string().min(1),
   /** Read overFile from the artifacts drawer instead of the project workspace. */
-  overArtifact: z5.boolean().optional(),
+  overArtifact: z6.boolean().optional(),
   /** Dotted path to the array inside `overFile`. Absent → the file itself is the array. */
-  itemsPath: z5.string().optional(),
+  itemsPath: z6.string().optional(),
   /** Entry step id of the child template. Defaults to the first `steps` entry. */
-  entryStepId: z5.string().optional(),
+  entryStepId: z6.string().optional(),
   /** The per-child step template — same shape as a craftbook's own steps. */
-  steps: z5.array(CraftbookStepSchema).min(1)
+  steps: z6.array(CraftbookStepSchema).min(1)
 });
 function validateCraftbookGraph(cb) {
   const problems = [];
@@ -1056,70 +1188,88 @@ function validateCraftbookGraph(cb) {
 function refineCraftbook(cb, ctx) {
   for (const message of validateCraftbookGraph(cb)) {
     ctx.addIssue({
-      code: z5.ZodIssueCode.custom,
+      code: z6.ZodIssueCode.custom,
       message,
       path: message.startsWith("entryStepId") ? ["entryStepId"] : ["steps"]
     });
   }
   for (const message of validateCraftbookScriptRefs(cb)) {
-    ctx.addIssue({ code: z5.ZodIssueCode.custom, message, path: ["steps"] });
+    ctx.addIssue({ code: z6.ZodIssueCode.custom, message, path: ["steps"] });
   }
 }
-var CraftbookRequirementSchema = z5.discriminatedUnion("kind", [
+var CraftbookRequirementSchema = z6.discriminatedUnion("kind", [
   /** The project is connected to a GitHub repository. */
-  z5.object({ kind: z5.literal("github") }),
+  z6.object({ kind: z6.literal("github") }),
   /** The project's current git branch is not the main line (main/master). */
-  z5.object({ kind: z5.literal("non-main-branch") })
+  z6.object({ kind: z6.literal("non-main-branch") })
+]);
+var CraftbookRecommendationSchema = z6.discriminatedUnion("kind", [
+  /**
+   * Works better with the install-wide External services capability
+   * (`securityPolicy.allowExternalServices`) — web search, URL fetch.
+   */
+  z6.object({
+    kind: z6.literal("external-services"),
+    /** Human-readable rationale shown in the nudge ("verifies sources with live web search"). */
+    reason: z6.string().optional()
+  })
 ]);
-var CraftbookRunModesSchema = z5.object({
-  scheduled: z5.enum(["supported", "recommended"]).optional(),
-  nightShift: z5.enum(["supported", "recommended"]).optional()
+var CraftbookRunModesSchema = z6.object({
+  scheduled: z6.enum(["supported", "recommended"]).optional(),
+  nightShift: z6.enum(["supported", "recommended"]).optional()
 });
-var CraftbookToolsetNeedSchema = z5.object({
+var CraftbookToolsetNeedSchema = z6.object({
   /** Catalog toolset id, e.g. `github`, `usb-camera`. */
-  toolsetId: z5.string().min(1),
+  toolsetId: z6.string().min(1),
   /** Catalog source provenance (bundled/community), when pinned. */
-  sourceId: z5.string().optional(),
+  sourceId: z6.string().optional(),
   /** Optional semver floor; presence is recorded but not yet enforced. */
-  minVersion: z5.string().optional(),
+  minVersion: z6.string().optional(),
   /**
    * When true, the need is a suggestion only — surfaced as a hint, never
    * blocks invocation. Default (absent/false) = required: the launcher
    * offers install before the craftbook can run.
    */
-  optional: z5.boolean().optional(),
+  optional: z6.boolean().optional(),
   /**
    * When true, pre-authorize every tool this toolset exposes for the
    * duration the craftbook is active — both via a synthesized PreToolUse
    * allow-hook (in-process providers) and the Claude-CLI permission
    * broker. Off by default; opt in for unattended/scheduled craftbooks.
    */
-  autoAllow: z5.boolean().optional(),
+  autoAllow: z6.boolean().optional(),
   /** Human-readable rationale shown in the launcher ("pull camera frames"). */
-  reason: z5.string().optional()
+  reason: z6.string().optional()
+});
+var CraftbookCommandNeedSchema = z6.object({
+  scope: z6.enum(["script", "npx"]),
+  name: z6.string().min(1),
+  args: z6.array(z6.string()).optional(),
+  reason: z6.string().optional(),
+  optional: z6.boolean().optional()
 });
-var CraftbookConnectorNeedSchema = z5.object({
+var CraftbookConnectorNeedSchema = z6.object({
   /** Catalog connector-type id, e.g. `github-pulls`, `mail-gmail`. */
-  typeId: z5.string().min(1),
+  typeId: z6.string().min(1),
   /** Catalog source provenance (bundled/community), when pinned. */
-  sourceId: z5.string().optional(),
+  sourceId: z6.string().optional(),
   /**
    * When true, the craftbook still runs without the connector bound —
    * the corpus is a bonus, not the substrate. Default (absent/false) =
    * required: the launcher offers to bind it before the craftbook runs.
    */
-  optional: z5.boolean().optional(),
+  optional: z6.boolean().optional(),
   /** Human-readable rationale shown in the launcher ("pull the PR diff"). */
-  reason: z5.string().optional()
+  reason: z6.string().optional()
 });
 var CRAFTBOOK_SCRIPT_MAX_BYTES = 64 * 1024;
 var CRAFTBOOK_SCRIPTS_TOTAL_MAX_BYTES = 256 * 1024;
 var CRAFTBOOK_SCRIPTS_MAX_COUNT = 24;
-var CraftbookScriptsSchema = z5.record(ScriptNameSchema, z5.string().min(1).max(CRAFTBOOK_SCRIPT_MAX_BYTES)).superRefine((scripts, ctx) => {
+var CraftbookScriptsSchema = z6.record(ScriptNameSchema, z6.string().min(1).max(CRAFTBOOK_SCRIPT_MAX_BYTES)).superRefine((scripts, ctx) => {
   const names = Object.keys(scripts);
   if (names.length > CRAFTBOOK_SCRIPTS_MAX_COUNT) {
     ctx.addIssue({
-      code: z5.ZodIssueCode.custom,
+      code: z6.ZodIssueCode.custom,
       message: `a craftbook carries at most ${CRAFTBOOK_SCRIPTS_MAX_COUNT} scripts (got ${names.length})`
     });
   }
@@ -1127,14 +1277,14 @@ var CraftbookScriptsSchema = z5.record(ScriptNameSchema, z5.string().min(1).max(
   for (const name of names) total += scripts[name].length;
   if (total > CRAFTBOOK_SCRIPTS_TOTAL_MAX_BYTES) {
     ctx.addIssue({
-      code: z5.ZodIssueCode.custom,
+      code: z6.ZodIssueCode.custom,
       message: `craftbook scripts total ${total} bytes \u2014 the ceiling is ${CRAFTBOOK_SCRIPTS_TOTAL_MAX_BYTES}`
     });
   }
 });
-var CraftbookBasedOnSchema = z5.object({
-  name: z5.string().min(1),
-  url: z5.string().url().regex(/^https?:\/\//i, "basedOn.url must use http or https")
+var CraftbookBasedOnSchema = z6.object({
+  name: z6.string().min(1),
+  url: z6.string().url().regex(/^https?:\/\//i, "basedOn.url must use http or https")
 });
 function validateCraftbookScriptRefs(cb) {
   if (!cb.scripts) return [];
@@ -1156,32 +1306,32 @@ function validateCraftbookScriptRefs(cb) {
   }
   return problems;
 }
-var CraftbookSchema = z5.object({
+var CraftbookSchema = z6.object({
   /** Matches catalog folder name. For ad-hoc embedded craftbooks (inline-steps tasks), a generated id. */
-  id: z5.string().min(1),
-  name: z5.string().min(1),
-  description: z5.string().optional(),
+  id: z6.string().min(1),
+  name: z6.string().min(1),
+  description: z6.string().optional(),
   /** Semver from the catalog version this craftbook was resolved from. Unset for ad-hoc embedded books. */
-  version: z5.string().optional(),
+  version: z6.string().optional(),
   /** Optional credit + link to the upstream work this craftbook adapts. */
   basedOn: CraftbookBasedOnSchema.optional(),
-  plan: z5.string().optional(),
+  plan: z6.string().optional(),
   defaultAssignee: TaskAssigneeSchema.optional(),
-  steps: z5.array(CraftbookStepSchema).min(1),
-  entryStepId: z5.string().min(1),
+  steps: z6.array(CraftbookStepSchema).min(1),
+  entryStepId: z6.string().min(1),
   /**
    * User-speech phrases that route to this craftbook. Matched
    * case-insensitively as substrings against the user's chat input
    * (or against a slash-command argument). Optional; absent =
    * invocable only via explicit `invoke_craftbook` / Commands panel.
    */
-  triggers: z5.array(z5.string()).optional(),
+  triggers: z6.array(z6.string()).optional(),
   /**
    * Pre/PostToolUse hooks installed for the duration the craftbook
    * is active. The MCP bridge consults this list before forwarding
    * a `tools/call`. See `hook.ts` for the decision contract.
    */
-  hooks: z5.array(HookSpecSchema).optional(),
+  hooks: z6.array(HookSpecSchema).optional(),
   /**
    * Optional squisq/JSON-Schema object describing the parameters this
    * craftbook collects before it runs. Its top-level `properties` are
@@ -1192,19 +1342,26 @@ var CraftbookSchema = z5.object({
    * structurally; typed as squisq's `SquisqAnnotatedSchema` at the UI
    * boundary. Absent = parameterless (the command is injected directly).
    */
-  paramSchema: z5.record(z5.string(), z5.unknown()).optional(),
+  paramSchema: z6.record(z6.string(), z6.unknown()).optional(),
   /**
    * CLI token the launcher stages into the terminal and that the
    * terminal recognizes. Defaults to `id` when absent — e.g. the
    * "Code Review" craftbook (id `review`) sets `command: "code-review"`.
    */
-  command: z5.string().regex(/^[a-z][a-z0-9-]*$/).optional(),
+  command: z6.string().regex(/^[a-z][a-z0-9-]*$/).optional(),
   /**
    * Prerequisites a project must satisfy for this craftbook to be
    * applicable. When unmet, the craftbook is hidden from the launcher
    * and not recognized as a terminal command. Absent = always offered.
    */
-  requirements: z5.array(CraftbookRequirementSchema).optional(),
+  requirements: z6.array(CraftbookRequirementSchema).optional(),
+  /**
+   * Soft "works better with" hints — never gate, only inform UI copy
+   * (the craftbook start card's permission nudge). See
+   * {@link CraftbookRecommendationSchema}. Carried into the runtime
+   * craftbook and the task snapshot, unlike `requirements`.
+   */
+  recommends: z6.array(CraftbookRecommendationSchema).optional(),
   /** Unattended launch modes this recipe is suitable for. */
   runModes: CraftbookRunModesSchema.optional(),
   /**
@@ -1215,7 +1372,14 @@ var CraftbookSchema = z5.object({
    * `requirements`, this is carried into the runtime craftbook and the task
    * snapshot. Absent = no declared toolset dependencies.
    */
-  toolsets: z5.array(CraftbookToolsetNeedSchema).optional(),
+  toolsets: z6.array(CraftbookToolsetNeedSchema).optional(),
+  /**
+   * Project commands this craftbook's `commandEvidence` gates verify runs
+   * of. See {@link CraftbookCommandNeedSchema}. Carried into the runtime
+   * craftbook and the task snapshot so the kickoff path can raise the
+   * first-use approval questions up front.
+   */
+  commands: z6.array(CraftbookCommandNeedSchema).optional(),
   /**
    * Connectors whose mirrored `artifacts/data/` corpus this craftbook reads. The
    * launcher binds and syncs them before the first step runs. See
@@ -1223,7 +1387,7 @@ var CraftbookSchema = z5.object({
    * craftbook and the task snapshot so a running task records what it
    * was launched against. Absent = no connector dependencies.
    */
-  connectors: z5.array(CraftbookConnectorNeedSchema).optional(),
+  connectors: z6.array(CraftbookConnectorNeedSchema).optional(),
   /**
    * Embedded script sources (name → TypeScript). See
    * {@link CraftbookScriptsSchema}. Hydrated at resolution time for
@@ -1239,10 +1403,30 @@ var CraftbookSchema = z5.object({
    * task snapshot so the runtime reads it at fanout time.
    */
   spawn: CraftbookSpawnSchema.optional(),
-  createdAt: z5.string(),
-  updatedAt: z5.string()
+  /**
+   * This craftbook is authored mode-agnostic: it works identically whether
+   * a run edits the workspace in place or drafts a diffpack change
+   * proposal. Concretely, its workspace deliverables and gates evaluate
+   * through the draft overlay, and it carries no mode-specific prose and
+   * no `{{diffpack.*}}` tokens — the runtime injects drafting framing and
+   * re-roots the write tools. Declaring it lets an invocation opt the run
+   * into proposing (`deliveryMode: 'propose'`, or automatically for
+   * unattended runs); the mode is a property of the RUN, never of the
+   * book. Resolution rule in `TaskManager.create`.
+   */
+  diffpackCapable: z6.boolean().optional(),
+  /**
+   * Minimum model tier for the WHOLE book: every step floors at least
+   * here (per-step `capabilityFloor` still overrides absolutely, and a
+   * stricter role floor still wins — see `effectiveCapabilityFloor` in
+   * roles/registry.ts). The honest "this recipe needs a medium model"
+   * declaration, consumed by per-step routing at dispatch.
+   */
+  capabilityFloor: ModelTierSchema.optional(),
+  createdAt: z6.string(),
+  updatedAt: z6.string()
 }).superRefine(refineCraftbook);
-var DeliverableKindSchema = z5.enum([
+var DeliverableKindSchema = z6.enum([
   "html-game",
   "html-multiscreen-game",
   "html-page",
@@ -1261,97 +1445,101 @@ var DeliverableKindSchema = z5.enum([
   "data-file",
   "generic-file"
 ]);
-var StepDeliverableSchema = z5.object({
+var StepDeliverableSchema = z6.object({
   /** Workspace-relative file the step must produce. The only required field. */
-  path: z5.string().min(1),
+  path: z6.string().min(1),
   /** Artifact class; inferred from the file extension when absent. */
   kind: DeliverableKindSchema.optional(),
   /** Override the class-default byte floor. */
-  minBytes: z5.number().int().positive().optional(),
+  minBytes: z6.number().int().positive().optional(),
   /** Gate rejections before the task pauses for help. */
-  maxAttempts: z5.number().int().positive().optional(),
+  maxAttempts: z6.number().int().positive().optional(),
   /** Gate the artifacts drawer instead of the workspace. */
-  artifact: z5.boolean().optional(),
+  artifact: z6.boolean().optional(),
   /**
    * The deliverable is an EDIT to a pre-existing file (fix/refactor):
    * presence alone never advances the step — the assignee must have
    * written to the file this turn. See {@link AdvanceWhenSchema}.
    */
-  requireChange: z5.boolean().optional(),
+  requireChange: z6.boolean().optional(),
   /**
    * For code deliverables: additionally execute the file in the sandbox
    * and require exit 0 (a `node:test`/`assert` file exits nonzero on
    * failure — exactly the contract). Opt-in.
    */
-  execute: z5.boolean().optional(),
+  execute: z6.boolean().optional(),
   /** For data deliverables: required column names (adds a tableShape check). */
-  columns: z5.array(z5.string().min(1)).min(1).optional(),
+  columns: z6.array(z6.string().min(1)).min(1).optional(),
   /** For data deliverables: minimum row count (adds a tableShape check). */
-  minRows: z5.number().int().positive().optional()
-});
-var NewCraftbookStepSchema = z5.object({
-  id: z5.string().optional(),
-  name: z5.string().min(1),
-  description: z5.string().optional(),
-  prompt: z5.string().optional(),
-  suggestedGezelId: z5.string().optional(),
+  minRows: z6.number().int().positive().optional()
+});
+var NewCraftbookStepSchema = z6.object({
+  id: z6.string().optional(),
+  name: z6.string().min(1),
+  description: z6.string().optional(),
+  prompt: z6.string().optional(),
+  suggestedGezelId: z6.string().optional(),
   /** See {@link CraftbookStepSchema.shape.suggestedRole}. */
-  suggestedRole: z5.string().optional(),
+  suggestedRole: z6.string().optional(),
   /** See {@link CraftbookStepSchema.shape.capabilityFloor}. */
   capabilityFloor: ModelTierSchema.optional(),
+  /** See {@link CraftbookStepSchema.shape.retrieval}. */
+  retrieval: RetrievalPolicySchema.optional(),
   assignee: TaskAssigneeSchema.optional(),
   onEnter: ScriptRefListSchema.optional(),
   onExit: ScriptRefListSchema.optional(),
-  consumes: z5.array(CraftbookStepInputSchema).min(1).optional().describe(
+  consumes: z6.array(CraftbookStepInputSchema).min(1).optional().describe(
     "Files this step must open before working. Artifact inputs also require an explicit `read_artifact` call in the step prompt."
   ),
   advanceWhen: AdvanceWhenSchema.optional(),
   gate: StepGateUnionSchema.optional(),
   /** See {@link StepDeliverableSchema} — one field attaches the enforced gate. */
   deliverable: StepDeliverableSchema.optional(),
-  next: z5.string().optional(),
-  branches: z5.array(CraftbookBranchSchema).optional(),
-  terminal: z5.boolean().optional(),
+  next: z6.string().optional(),
+  branches: z6.array(CraftbookBranchSchema).optional(),
+  terminal: z6.boolean().optional(),
   /** See {@link CraftbookStepSchema.shape.spawnFanout}. */
-  spawnFanout: z5.boolean().optional()
+  spawnFanout: z6.boolean().optional()
 });
-var CreateCraftbookRequestSchema = z5.object({
-  id: z5.string().optional(),
-  name: z5.string().min(1),
-  description: z5.string().optional(),
+var CreateCraftbookRequestSchema = z6.object({
+  id: z6.string().optional(),
+  name: z6.string().min(1),
+  description: z6.string().optional(),
   basedOn: CraftbookBasedOnSchema.optional(),
-  plan: z5.string().optional(),
+  plan: z6.string().optional(),
   defaultAssignee: TaskAssigneeSchema.optional(),
-  steps: z5.array(NewCraftbookStepSchema).min(1),
-  entryStepId: z5.string().optional(),
-  paramSchema: z5.record(z5.string(), z5.unknown()).optional(),
-  command: z5.string().regex(/^[a-z][a-z0-9-]*$/).optional(),
-  requirements: z5.array(CraftbookRequirementSchema).optional(),
+  steps: z6.array(NewCraftbookStepSchema).min(1),
+  entryStepId: z6.string().optional(),
+  paramSchema: z6.record(z6.string(), z6.unknown()).optional(),
+  command: z6.string().regex(/^[a-z][a-z0-9-]*$/).optional(),
+  requirements: z6.array(CraftbookRequirementSchema).optional(),
+  recommends: z6.array(CraftbookRecommendationSchema).optional(),
   runModes: CraftbookRunModesSchema.optional(),
-  toolsets: z5.array(CraftbookToolsetNeedSchema).optional(),
+  toolsets: z6.array(CraftbookToolsetNeedSchema).optional(),
   scripts: CraftbookScriptsSchema.optional()
 });
-var UpdateCraftbookRequestSchema = z5.object({
-  name: z5.string().min(1).optional(),
-  description: z5.string().nullable().optional(),
+var UpdateCraftbookRequestSchema = z6.object({
+  name: z6.string().min(1).optional(),
+  description: z6.string().nullable().optional(),
   basedOn: CraftbookBasedOnSchema.nullable().optional(),
-  plan: z5.string().nullable().optional(),
+  plan: z6.string().nullable().optional(),
   defaultAssignee: TaskAssigneeSchema.nullable().optional(),
-  steps: z5.array(NewCraftbookStepSchema).min(1).optional(),
-  entryStepId: z5.string().optional(),
-  paramSchema: z5.record(z5.string(), z5.unknown()).nullable().optional(),
-  command: z5.string().regex(/^[a-z][a-z0-9-]*$/).nullable().optional(),
-  requirements: z5.array(CraftbookRequirementSchema).nullable().optional(),
+  steps: z6.array(NewCraftbookStepSchema).min(1).optional(),
+  entryStepId: z6.string().optional(),
+  paramSchema: z6.record(z6.string(), z6.unknown()).nullable().optional(),
+  command: z6.string().regex(/^[a-z][a-z0-9-]*$/).nullable().optional(),
+  requirements: z6.array(CraftbookRequirementSchema).nullable().optional(),
+  recommends: z6.array(CraftbookRecommendationSchema).nullable().optional(),
   runModes: CraftbookRunModesSchema.nullable().optional(),
-  toolsets: z5.array(CraftbookToolsetNeedSchema).nullable().optional(),
+  toolsets: z6.array(CraftbookToolsetNeedSchema).nullable().optional(),
   /** Full-replace semantics: the map is the truth. `null` clears all scripts. */
   scripts: CraftbookScriptsSchema.nullable().optional()
 });
-var CraftbookSummarySchema = z5.object({
-  id: z5.string(),
-  name: z5.string(),
-  description: z5.string().optional(),
-  version: z5.string().optional(),
+var CraftbookSummarySchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  description: z6.string().optional(),
+  version: z6.string().optional(),
   basedOn: CraftbookBasedOnSchema.optional(),
   /**
    * Where the craftbook came from. `bundled` — shipped catalog;
@@ -1360,51 +1548,51 @@ var CraftbookSummarySchema = z5.object({
    * folder (often auto-imported from a `.claude/skills` / `agents/skills`
    * SKILL.md). Project craftbooks only surface inside their own project.
    */
-  source: z5.enum(["bundled", "local", "project"]),
-  stepCount: z5.number().int().nonnegative()
+  source: z6.enum(["bundled", "local", "project"]),
+  stepCount: z6.number().int().nonnegative()
 });
-var ListCraftbooksResponseSchema = z5.object({
-  craftbooks: z5.array(CraftbookSummarySchema)
+var ListCraftbooksResponseSchema = z6.object({
+  craftbooks: z6.array(CraftbookSummarySchema)
 });
-var ProjectCraftbookProvenanceSchema = z5.object({
-  installedBy: z5.literal("project-type"),
-  typeId: z5.string(),
-  typeVersion: z5.string(),
-  bookVersion: z5.string(),
+var ProjectCraftbookProvenanceSchema = z6.object({
+  installedBy: z6.literal("project-type"),
+  typeId: z6.string(),
+  typeVersion: z6.string(),
+  bookVersion: z6.string(),
   /** sha256 over the installed book's canonical recipe JSON. */
-  contentHash: z5.string(),
-  installedAt: z5.string()
-});
-var CraftbookSuggestionSchema = z5.object({
-  id: z5.string(),
-  name: z5.string(),
-  description: z5.string().optional(),
-  source: z5.enum(["bundled", "local", "project"]),
-  version: z5.string().optional(),
+  contentHash: z6.string(),
+  installedAt: z6.string()
+});
+var CraftbookSuggestionSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  description: z6.string().optional(),
+  source: z6.enum(["bundled", "local", "project"]),
+  version: z6.string().optional(),
   basedOn: CraftbookBasedOnSchema.optional(),
-  stepCount: z5.number().int().nonnegative(),
-  tags: z5.array(z5.string()).optional(),
-  triggers: z5.array(z5.string()).optional(),
-  score: z5.number(),
-  semantic: z5.number().optional(),
-  lexical: z5.number()
+  stepCount: z6.number().int().nonnegative(),
+  tags: z6.array(z6.string()).optional(),
+  triggers: z6.array(z6.string()).optional(),
+  score: z6.number(),
+  semantic: z6.number().optional(),
+  lexical: z6.number()
 });
-var SuggestCraftbooksResponseSchema = z5.object({
-  suggestions: z5.array(CraftbookSuggestionSchema)
+var SuggestCraftbooksResponseSchema = z6.object({
+  suggestions: z6.array(CraftbookSuggestionSchema)
 });
-var CraftbookResponseSchema = z5.object({
+var CraftbookResponseSchema = z6.object({
   craftbook: CraftbookSchema
 });
 function slugifyStepId(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "step";
 }
-var StepPositionSchema = z5.object({
+var StepPositionSchema = z6.object({
   /** Insert immediately after the step with this id. */
-  after: z5.string().optional(),
+  after: z6.string().optional(),
   /** Insert immediately before the step with this id. */
-  before: z5.string().optional(),
+  before: z6.string().optional(),
   /** Absolute insertion index (clamped to [0, length]). */
-  index: z5.number().int().nonnegative().optional()
+  index: z6.number().int().nonnegative().optional()
 });
 
 // src/markdown/frontmatter.ts
@@ -1580,11 +1768,21 @@ var FRONTMATTER_KEYS = [
   "plan",
   "defaultAssignee",
   "requirements",
+  "recommends",
   "runModes",
   "toolsets",
   "connectors",
   "paramSchema",
   "hooks",
+  // Whole-book declarations that are NOT step fields. Omitting one here is
+  // worse than dropping it: the parser reports `unknown key "spawn"` and
+  // refuses the save, so a model that correctly authored a fanout book in
+  // the markdown arm is told its document is malformed.
+  "spawn",
+  "commands",
+  "diffpackCapable",
+  "capabilityFloor",
+  "minGezelVersion",
   "version",
   "releasedAt"
 ];
@@ -1603,7 +1801,10 @@ var STEP_FENCE_KEYS = [
   "gate",
   "next",
   "branches",
-  "terminal"
+  "terminal",
+  // Marks the step the spawn block fans out from. Without it a book can
+  // declare `spawn` and have no step that triggers it.
+  "spawnFanout"
 ];
 function parseCraftbookMarkdown(text) {
   const errors = [];
@@ -1791,10 +1992,10 @@ function defaultStepIdForName(name) {
 }
 
 // src/schemas/gezel.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 
 // src/poppetje/schema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/poppetje/catalogs.ts
 var BODY_ARCHETYPES = {
@@ -1940,45 +2141,45 @@ function migrateLegacyAccessory(raw) {
   }
   return r;
 }
-var PoppetjeSchema = z6.preprocess(
+var PoppetjeSchema = z7.preprocess(
   migrateLegacyAccessory,
-  z6.object({
+  z7.object({
     /** Stable id; locks the wood-grain noise seed. Pin to the gezel id at creation. */
-    key: z6.string().min(1),
-    name: z6.string(),
-    bodyShape: z6.enum(BODY_SHAPE_KEYS),
-    figureScale: z6.enum(FIGURE_SCALE_KEYS),
+    key: z7.string().min(1),
+    name: z7.string(),
+    bodyShape: z7.enum(BODY_SHAPE_KEYS),
+    figureScale: z7.enum(FIGURE_SCALE_KEYS),
     /** Mid-tone of the head. Paired with skin2 for the lateral gradient. */
-    skin: z6.string(),
+    skin: z7.string(),
     /** Darker edge tone. */
-    skin2: z6.string(),
-    hair: z6.string(),
-    hairShape: z6.enum(HAIR_SHAPES),
+    skin2: z7.string(),
+    hair: z7.string(),
+    hairShape: z7.enum(HAIR_SHAPES),
     /** Replaces hair when set; 'hood' renders at body level. */
-    hat: z6.enum(HAT_OPTIONS).nullable().optional().default(null),
+    hat: z7.enum(HAT_OPTIONS).nullable().optional().default(null),
     /** Body overlay; null for an unadorned shirt. */
-    dress: z6.enum(DRESS_OPTIONS).nullable().optional().default(null),
+    dress: z7.enum(DRESS_OPTIONS).nullable().optional().default(null),
     /** Wearable face accessory (glasses, earring, monocle). User-toggleable. */
-    accessory: z6.enum(ACCESSORY_OPTIONS).nullable().optional().default(null),
+    accessory: z7.enum(ACCESSORY_OPTIONS).nullable().optional().default(null),
     /** Facial hair (beard, mustache). Physical — reroll-only. */
-    facialHair: z6.enum(FACIAL_HAIR_OPTIONS).nullable().optional().default(null),
+    facialHair: z7.enum(FACIAL_HAIR_OPTIONS).nullable().optional().default(null),
     /** Small facial detail (freckles, mole). Physical — reroll-only. */
-    mark: z6.enum(MARK_OPTIONS).nullable().optional().default(null),
-    expression: z6.enum(EXPRESSION_OPTIONS).optional().default("smile"),
-    shirt: z6.string(),
-    shirtAccent: z6.string(),
+    mark: z7.enum(MARK_OPTIONS).nullable().optional().default(null),
+    expression: z7.enum(EXPRESSION_OPTIONS).optional().default("smile"),
+    shirt: z7.string(),
+    shirtAccent: z7.string(),
     /**
      * Painted garment pattern over the shirt (buttons, stripes, sash, …).
      * Files written before patterns existed parse as `plain` — the bare
      * shirt those characters always had.
      */
-    shirtPattern: z6.enum(SHIRT_PATTERN_OPTIONS).optional().default("plain")
+    shirtPattern: z7.enum(SHIRT_PATTERN_OPTIONS).optional().default("plain")
   })
 );
 
 // src/schemas/claude.ts
-import { z as z7 } from "zod";
-var ClaudePermissionModeSchema = z7.enum([
+import { z as z8 } from "zod";
+var ClaudePermissionModeSchema = z8.enum([
   "default",
   "acceptEdits",
   "plan",
@@ -1986,20 +2187,20 @@ var ClaudePermissionModeSchema = z7.enum([
 ]);
 
 // src/schemas/codex.ts
-import { z as z8 } from "zod";
-var CodexPermissionModeSchema = z8.enum(["plan", "edit", "reviewed", "full"]);
-var LegacyCodexPermissionModeSchema = z8.enum([
+import { z as z9 } from "zod";
+var CodexPermissionModeSchema = z9.enum(["plan", "edit", "reviewed", "full"]);
+var LegacyCodexPermissionModeSchema = z9.enum([
   "default",
   "acceptEdits",
   "bypassPermissions"
 ]);
-var CodexPermissionModeCompatSchema = z8.union([
+var CodexPermissionModeCompatSchema = z9.union([
   CodexPermissionModeSchema,
   LegacyCodexPermissionModeSchema
 ]);
 
 // src/schemas/entity-id.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/entity-id.ts
 var SAFE_ENTITY_ID = /^[A-Za-z0-9@][A-Za-z0-9@._-]{0,199}$/;
@@ -2034,169 +2235,169 @@ function isSafeEntityId(value) {
 }
 
 // src/schemas/entity-id.ts
-var EntityIdSchema = z9.string().refine(isSafeEntityId, {
+var EntityIdSchema = z10.string().refine(isSafeEntityId, {
   message: "must be a portable single-segment entity id"
 });
 
 // src/schemas/growth.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/schemas/tuning-profile-registry.ts
-import { z as z10 } from "zod";
-var TuningProfileIdSchema = z10.string().min(1).describe("Canonical tuning profile id.");
+import { z as z11 } from "zod";
+var TuningProfileIdSchema = z11.string().min(1).describe("Canonical tuning profile id.");
 
 // src/schemas/growth.ts
-var GrowthEvidenceSchema = z11.object({
+var GrowthEvidenceSchema = z12.object({
   /** Memory-file day (YYYY-MM-DD) — rewritten server-side from the matched entry. */
-  day: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-  kind: z11.enum(["fact", "decision", "pref", "status"]),
-  excerpt: z11.string().min(1).max(400)
-});
-var TraitProposalSchema = z11.object({
-  id: z11.string(),
-  kind: z11.literal("trait"),
-  title: z11.string().min(1).max(80),
+  day: z12.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  kind: z12.enum(["fact", "decision", "pref", "status"]),
+  excerpt: z12.string().min(1).max(400)
+});
+var TraitProposalSchema = z12.object({
+  id: z12.string(),
+  kind: z12.literal("trait"),
+  title: z12.string().min(1).max(80),
   /** One imperative second-person sentence destined for the prompt. */
-  traitText: z11.string().min(1).max(200),
-  evidence: z11.array(GrowthEvidenceSchema).min(1).max(3)
+  traitText: z12.string().min(1).max(200),
+  evidence: z12.array(GrowthEvidenceSchema).min(1).max(3)
 });
-var TuningActionSchema = z11.discriminatedUnion("type", [
-  z11.object({ type: z11.literal("profile"), profile: TuningProfileIdSchema }),
+var TuningActionSchema = z12.discriminatedUnion("type", [
+  z12.object({ type: z12.literal("profile"), profile: TuningProfileIdSchema }),
   /** Resolved + clamped at accept time against the then-current frontmatter. */
-  z11.object({ type: z11.literal("temperature"), delta: z11.union([z11.literal(0.1), z11.literal(-0.1)]) })
+  z12.object({ type: z12.literal("temperature"), delta: z12.union([z12.literal(0.1), z12.literal(-0.1)]) })
 ]);
-var TuningProposalSchema = z11.object({
-  id: z11.string(),
-  kind: z11.literal("tuning"),
-  title: z11.string().max(80),
-  description: z11.string().max(300),
+var TuningProposalSchema = z12.object({
+  id: z12.string(),
+  kind: z12.literal("tuning"),
+  title: z12.string().max(80),
+  description: z12.string().max(300),
   action: TuningActionSchema
 });
-var CosmeticProposalSchema = z11.object({
-  id: z11.string(),
-  kind: z11.literal("cosmetic"),
-  title: z11.string().max(80),
+var CosmeticProposalSchema = z12.object({
+  id: z12.string(),
+  kind: z12.literal("cosmetic"),
+  title: z12.string().max(80),
   /** Key into GROWTH_COSMETICS, or a generic `level-N` milestone marker. */
-  cosmeticId: z11.string()
+  cosmeticId: z12.string()
 });
-var GrowthProposalSchema = z11.discriminatedUnion("kind", [
+var GrowthProposalSchema = z12.discriminatedUnion("kind", [
   TraitProposalSchema,
   TuningProposalSchema,
   CosmeticProposalSchema
 ]);
-var PendingLevelUpSchema = z11.object({
-  toLevel: z11.number().int().min(2),
-  proposals: z11.array(GrowthProposalSchema).min(1).max(5),
-  createdAt: z11.string()
-});
-var GrowthSignalsSchema = z11.object({
-  memoryXp: z11.number().int().nonnegative().default(0),
-  lessonsXp: z11.number().int().nonnegative().default(0),
-  taskXp: z11.number().int().nonnegative().default(0),
-  consultXp: z11.number().int().nonnegative().default(0)
-});
-var AdoptedTraitRecordSchema = z11.object({
-  traitId: z11.string(),
-  text: z11.string(),
-  level: z11.number().int(),
-  adoptedAt: z11.string(),
-  evidence: z11.array(GrowthEvidenceSchema),
+var PendingLevelUpSchema = z12.object({
+  toLevel: z12.number().int().min(2),
+  proposals: z12.array(GrowthProposalSchema).min(1).max(5),
+  createdAt: z12.string()
+});
+var GrowthSignalsSchema = z12.object({
+  memoryXp: z12.number().int().nonnegative().default(0),
+  lessonsXp: z12.number().int().nonnegative().default(0),
+  taskXp: z12.number().int().nonnegative().default(0),
+  consultXp: z12.number().int().nonnegative().default(0)
+});
+var AdoptedTraitRecordSchema = z12.object({
+  traitId: z12.string(),
+  text: z12.string(),
+  level: z12.number().int(),
+  adoptedAt: z12.string(),
+  evidence: z12.array(GrowthEvidenceSchema),
   /** Set when the user later retires the trait — kept for the character sheet. */
-  removedAt: z11.string().optional()
+  removedAt: z12.string().optional()
 });
-var DeclinedProposalRecordSchema = z11.object({
-  kind: z11.enum(["trait", "tuning", "cosmetic"]),
-  title: z11.string(),
+var DeclinedProposalRecordSchema = z12.object({
+  kind: z12.enum(["trait", "tuning", "cosmetic"]),
+  title: z12.string(),
   /** Used for never-re-offer matching on trait proposals. */
-  traitText: z11.string().optional(),
-  level: z11.number().int(),
-  declinedAt: z11.string()
-});
-var GezelGrowthStateSchema = z11.object({
-  version: z11.literal(1).default(1),
-  level: z11.number().int().min(1).default(1),
-  xp: z11.number().int().nonnegative().default(0),
+  traitText: z12.string().optional(),
+  level: z12.number().int(),
+  declinedAt: z12.string()
+});
+var GezelGrowthStateSchema = z12.object({
+  version: z12.literal(1).default(1),
+  level: z12.number().int().min(1).default(1),
+  xp: z12.number().int().nonnegative().default(0),
   signals: GrowthSignalsSchema.prefault({}),
-  lastComputedAt: z11.string().optional(),
+  lastComputedAt: z12.string().optional(),
   pendingLevelUp: PendingLevelUpSchema.optional(),
-  adoptedTraits: z11.array(AdoptedTraitRecordSchema).default([]),
-  declinedProposals: z11.array(DeclinedProposalRecordSchema).default([]),
-  unlockedCosmetics: z11.array(z11.object({ id: z11.string(), at: z11.string() })).default([])
+  adoptedTraits: z12.array(AdoptedTraitRecordSchema).default([]),
+  declinedProposals: z12.array(DeclinedProposalRecordSchema).default([]),
+  unlockedCosmetics: z12.array(z12.object({ id: z12.string(), at: z12.string() })).default([])
 });
-var GezelGrowthSummarySchema = z11.object({
-  level: z11.number().int().min(1),
+var GezelGrowthSummarySchema = z12.object({
+  level: z12.number().int().min(1),
   /** True when a level-up is waiting for the user's choice. */
-  pending: z11.boolean().optional()
+  pending: z12.boolean().optional()
 });
 
 // src/schemas/model-tuning.ts
-import { z as z12 } from "zod";
-var DrySamplerSchema = z12.object({
-  multiplier: z12.number().min(0).max(5).describe("DRY penalty strength. 0 disables. 0.8 is a reasonable default."),
-  base: z12.number().min(0).max(5).optional().describe("Base of the exponential penalty for repeated tokens. Default 1.75."),
-  allowedLength: z12.number().int().min(0).max(64).optional().describe("Minimum n-gram length before DRY kicks in. Default 2.")
+import { z as z13 } from "zod";
+var DrySamplerSchema = z13.object({
+  multiplier: z13.number().min(0).max(5).describe("DRY penalty strength. 0 disables. 0.8 is a reasonable default."),
+  base: z13.number().min(0).max(5).optional().describe("Base of the exponential penalty for repeated tokens. Default 1.75."),
+  allowedLength: z13.number().int().min(0).max(64).optional().describe("Minimum n-gram length before DRY kicks in. Default 2.")
 }).describe("DRY anti-repetition sampler (llama.cpp only).");
-var XtcSamplerSchema = z12.object({
-  probability: z12.number().min(0).max(1).describe("Probability of triggering XTC on any given step."),
-  threshold: z12.number().min(0).max(1).describe("Minimum top-token probability for XTC to fire.")
+var XtcSamplerSchema = z13.object({
+  probability: z13.number().min(0).max(1).describe("Probability of triggering XTC on any given step."),
+  threshold: z13.number().min(0).max(1).describe("Minimum top-token probability for XTC to fire.")
 }).describe("XTC sampler (llama.cpp only).");
-var SamplingBlockSchema = z12.object({
-  temperature: z12.number().min(0).max(2).optional().describe("Sampling temperature. 0 = greedy. Most reasoning models want 0.6\u20131.0."),
-  topP: z12.number().min(0).max(1).optional().describe("Nucleus sampling. 0.95 is the common default for Qwen, Gemma, Nemotron."),
-  topK: z12.number().int().min(0).max(1e3).optional().describe("Top-k cutoff. 20 for Qwen think, 64 for Gemma, 1 for greedy-on-instruct."),
-  minP: z12.number().min(0).max(1).optional().describe("Min-p cutoff (llama.cpp / MLX / Ollama). Qwen recommends 0."),
-  maxTokens: z12.number().int().positive().optional().describe("Per-turn output token cap. Maps to num_predict / max_tokens / n_predict."),
-  seed: z12.number().int().optional().describe("RNG seed. Unset / negative = random. Best-effort determinism on cloud."),
-  repetitionPenalty: z12.number().min(0).max(3).optional().describe("Local engines (Ollama / llama.cpp / MLX): repeat_penalty. 1.0 = off, 1.1 = mild."),
-  repetitionContext: z12.number().int().positive().optional().describe("Local engines: window size for repetition penalty (`repeat_last_n`)."),
-  frequencyPenalty: z12.number().min(-2).max(2).optional().describe("Cloud (OpenAI) and Ollama / llama.cpp: penalize repeated tokens by frequency."),
-  presencePenalty: z12.number().min(-2).max(2).optional().describe("Cloud (OpenAI) and Ollama / llama.cpp: penalize any reused token."),
+var SamplingBlockSchema = z13.object({
+  temperature: z13.number().min(0).max(2).optional().describe("Sampling temperature. 0 = greedy. Most reasoning models want 0.6\u20131.0."),
+  topP: z13.number().min(0).max(1).optional().describe("Nucleus sampling. 0.95 is the common default for Qwen, Gemma, Nemotron."),
+  topK: z13.number().int().min(0).max(1e3).optional().describe("Top-k cutoff. 20 for Qwen think, 64 for Gemma, 1 for greedy-on-instruct."),
+  minP: z13.number().min(0).max(1).optional().describe("Min-p cutoff (llama.cpp / MLX / Ollama). Qwen recommends 0."),
+  maxTokens: z13.number().int().positive().optional().describe("Per-turn output token cap. Maps to num_predict / max_tokens / n_predict."),
+  seed: z13.number().int().optional().describe("RNG seed. Unset / negative = random. Best-effort determinism on cloud."),
+  repetitionPenalty: z13.number().min(0).max(3).optional().describe("Local engines (Ollama / llama.cpp / MLX): repeat_penalty. 1.0 = off, 1.1 = mild."),
+  repetitionContext: z13.number().int().positive().optional().describe("Local engines: window size for repetition penalty (`repeat_last_n`)."),
+  frequencyPenalty: z13.number().min(-2).max(2).optional().describe("Cloud (OpenAI) and Ollama / llama.cpp: penalize repeated tokens by frequency."),
+  presencePenalty: z13.number().min(-2).max(2).optional().describe("Cloud (OpenAI) and Ollama / llama.cpp: penalize any reused token."),
   dry: DrySamplerSchema.optional(),
   xtc: XtcSamplerSchema.optional()
 }).describe("Sampling parameters applied per-request.");
-var ReasoningBlockSchema = z12.object({
-  effort: z12.enum(["low", "medium", "high"]).optional().describe(
+var ReasoningBlockSchema = z13.object({
+  effort: z13.enum(["low", "medium", "high"]).optional().describe(
     "Cloud reasoning effort. Maps to OpenAI `reasoning.effort` and Anthropic `thinking.budget_tokens` tiers."
   ),
-  thinkingBudget: z12.number().int().positive().optional().describe(
+  thinkingBudget: z13.number().int().positive().optional().describe(
     "Explicit thinking-token budget (Anthropic `thinking.budget_tokens`, Nemotron `reasoning_budget`). Wins over `effort` when both set."
   ),
-  enableThinking: z12.boolean().optional().describe(
+  enableThinking: z13.boolean().optional().describe(
     "Chat-template toggle for dual-mode models (Qwen3+, Nemotron Nano/Super). Implicit on cloud thinking models."
   ),
-  templateKwargs: z12.record(z12.string(), z12.union([z12.string(), z12.number(), z12.boolean()])).optional().describe(
+  templateKwargs: z13.record(z13.string(), z13.union([z13.string(), z13.number(), z13.boolean()])).optional().describe(
     "Chat-template variables that drive this model's reasoning depth, forwarded verbatim as `chat_template_kwargs` on local engines. The names are the model's own \u2014 GPT-OSS reads `reasoning_effort`, Muse Glimmer reads `reasoning_strength` (low|medium|high|xhigh) \u2014 so the manifest declares them rather than the runtime guessing. Lives under `reasoning` (not `engine`) because depth is a per-request choice a tuning profile overrides: `thinking-coding` can ask for xhigh while `instruct` asks for low. Cloud providers ignore it; use `reasoning.effort` there."
   )
 }).describe("Reasoning controls.");
-var StructuredOutputSchema = z12.object({
-  responseFormat: z12.enum(["text", "json_object"]).optional().describe("Output mode. `text` = freeform (default). `json_object` = enforce JSON."),
-  jsonSchema: z12.unknown().optional().describe("Pin output to a JSON Schema (OpenAI strict mode, llama.cpp --json-schema)."),
-  grammar: z12.string().optional().describe("llama.cpp GBNF grammar. Last-resort structured-output knob.")
+var StructuredOutputSchema = z13.object({
+  responseFormat: z13.enum(["text", "json_object"]).optional().describe("Output mode. `text` = freeform (default). `json_object` = enforce JSON."),
+  jsonSchema: z13.unknown().optional().describe("Pin output to a JSON Schema (OpenAI strict mode, llama.cpp --json-schema)."),
+  grammar: z13.string().optional().describe("llama.cpp GBNF grammar. Last-resort structured-output knob.")
 }).describe("Structured-output controls.");
-var PromptTagsSchema = z12.object({
-  enableThinkingTag: z12.string().optional().describe("User-prompt tag that enables thinking for this turn (e.g. `/think`)."),
-  disableThinkingTag: z12.string().optional().describe("User-prompt tag that disables thinking for this turn (e.g. `/no_think`).")
+var PromptTagsSchema = z13.object({
+  enableThinkingTag: z13.string().optional().describe("User-prompt tag that enables thinking for this turn (e.g. `/think`)."),
+  disableThinkingTag: z13.string().optional().describe("User-prompt tag that disables thinking for this turn (e.g. `/no_think`).")
 }).describe("Per-turn reasoning toggle tags.");
-var LlamaCppEngineConfigSchema = z12.object({
-  nGpuLayers: z12.number().int().min(-1).optional().describe("`--n-gpu-layers` override. -1 = all. Unset = b9843 `auto`/`--fit`."),
-  cpuMoe: z12.boolean().optional().describe("`--cpu-moe`: keep ALL MoE experts in system RAM (attention/dense on GPU)."),
-  nCpuMoe: z12.number().int().min(0).optional().describe("`--n-cpu-moe N`: keep the first N layers\u2019 MoE experts in RAM. Partial split."),
-  cacheReuse: z12.number().int().min(0).optional().describe(
+var LlamaCppEngineConfigSchema = z13.object({
+  nGpuLayers: z13.number().int().min(-1).optional().describe("`--n-gpu-layers` override. -1 = all. Unset = b9843 `auto`/`--fit`."),
+  cpuMoe: z13.boolean().optional().describe("`--cpu-moe`: keep ALL MoE experts in system RAM (attention/dense on GPU)."),
+  nCpuMoe: z13.number().int().min(0).optional().describe("`--n-cpu-moe N`: keep the first N layers\u2019 MoE experts in RAM. Partial split."),
+  cacheReuse: z13.number().int().min(0).optional().describe(
     "`--cache-reuse N` prefix-KV reuse chunk. 0 = disable. Unset inherits the global default."
   ),
-  swaFull: z12.boolean().optional().describe("`--swa-full`: full-size SWA cache (Gemma family)."),
-  flashAttn: z12.enum(["on", "off", "auto"]).optional().describe("`--flash-attn` mode override for this model."),
-  ubatchSize: z12.number().int().positive().optional().describe("`--ubatch-size` (inner microbatch) override for this model."),
-  contextSize: z12.number().int().positive().optional().describe(
+  swaFull: z13.boolean().optional().describe("`--swa-full`: full-size SWA cache (Gemma family)."),
+  flashAttn: z13.enum(["on", "off", "auto"]).optional().describe("`--flash-attn` mode override for this model."),
+  ubatchSize: z13.number().int().positive().optional().describe("`--ubatch-size` (inner microbatch) override for this model."),
+  contextSize: z13.number().int().positive().optional().describe(
     "Per-turn context ceiling (tokens) this model launches with. Capped by GGUF train ctx."
   ),
-  chatTemplate: z12.string().min(1).optional().describe(
+  chatTemplate: z13.string().min(1).optional().describe(
     "`--chat-template` override for GGUFs whose embedded Jinja template is incompatible with llama.cpp tool parsing."
   ),
-  threads: z12.number().int().positive().optional().describe("`--threads` override."),
-  batchSize: z12.number().int().positive().optional().describe("`--batch-size` override."),
-  spec: z12.object({
-    type: z12.enum([
+  threads: z13.number().int().positive().optional().describe("`--threads` override."),
+  batchSize: z13.number().int().positive().optional().describe("`--batch-size` override."),
+  spec: z13.object({
+    type: z13.enum([
       "none",
       "draft-mtp",
       "draft-eagle3",
@@ -2208,24 +2409,24 @@ var LlamaCppEngineConfigSchema = z12.object({
       "ngram-map-k4v",
       "ngram-cache"
     ]).optional().describe("`--spec-type` speculative-decoding mode for this model."),
-    mtp: z12.boolean().optional().describe(
+    mtp: z13.boolean().optional().describe(
       "VERIFIED capability metadata: this model\u2019s target or companion GGUF carries MTP tensors. Does not enable `draft-mtp` by itself."
     ),
-    draftModelId: z12.string().optional().describe("Catalog id / path of the draft model for `draft-simple`."),
-    nMax: z12.number().int().positive().optional().describe("`--spec-draft-n-max`: tokens drafted per step.")
+    draftModelId: z13.string().optional().describe("Catalog id / path of the draft model for `draft-simple`."),
+    nMax: z13.number().int().positive().optional().describe("`--spec-draft-n-max`: tokens drafted per step.")
   }).optional().describe("Speculative-decoding config for this model.")
 }).describe("Per-model llama.cpp launch-flag defaults (engine-level, applied at model load).");
-var EngineConfigSchema = z12.object({
+var EngineConfigSchema = z13.object({
   llamaCpp: LlamaCppEngineConfigSchema.optional()
 }).describe("Per-model engine launch-flag defaults, keyed by engine.");
-var ChatModelTuningBaseSchema = z12.object({
+var ChatModelTuningBaseSchema = z13.object({
   sampling: SamplingBlockSchema.optional(),
   samplingWhenThinking: SamplingBlockSchema.optional().describe(
     "Sparse override of `sampling` applied when the runtime determines reasoning is engaged. Used by Qwen3+ (different sampling for /think mode) and Nemotron Nano (different sampling for thinking vs instruct)."
   ),
   reasoning: ReasoningBlockSchema.optional(),
   output: StructuredOutputSchema.optional(),
-  toolChoice: z12.enum(["auto", "required", "none"]).optional().describe(
+  toolChoice: z13.enum(["auto", "required", "none"]).optional().describe(
     "Tool selection mode (cloud + llama.cpp + MLX). `auto` lets the model decide; `required` forces a tool call this turn; `none` disables tools."
   ),
   promptTags: PromptTagsSchema.optional()
@@ -2234,16 +2435,16 @@ var ChatModelTuningSchema = ChatModelTuningBaseSchema.extend({
   engine: EngineConfigSchema.optional().describe(
     "Per-model ENGINE launch-flag defaults (llama.cpp `--n-gpu-layers`, `--cpu-moe`, `--spec-type`, \u2026). Applied once at model load, not per request \u2014 so it lives on the top-level tuning object, not inside per-request `profiles`."
   ),
-  profiles: z12.record(TuningProfileIdSchema, ChatModelTuningBaseSchema.partial()).optional().describe(
+  profiles: z13.record(TuningProfileIdSchema, ChatModelTuningBaseSchema.partial()).optional().describe(
     "Named tuning presets this model implements. Gezel frontmatter `tuningProfile` selects one; the resolver applies the profile as a layer between installDefault and catalog base. Missing requested profiles walk the canonical fallback chain."
   )
 }).describe("Per-model sampling, reasoning, and output defaults.");
 
 // src/schemas/question.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/schemas/npm-package.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var NPM_NAME_SEGMENT = /^[a-z0-9](?:[a-z0-9._~-]*[a-z0-9])?$/;
 var SEMVER_NUMBER = String.raw`(?:0|[1-9]\d*)`;
 var SEMVER_PART = String.raw`(?:${SEMVER_NUMBER}|[xX*])`;
@@ -2275,36 +2476,41 @@ function isValidNpmRegistryVersion(value) {
     return atoms.length > 0 && atoms.every((atom) => SEMVER_ATOM.test(atom));
   });
 }
-var NpmPackageNameSchema = z13.string().refine(isValidNpmPackageName, {
+var NpmPackageNameSchema = z14.string().refine(isValidNpmPackageName, {
   message: "must be a lowercase npm registry package name (for example zod or @types/node)"
 });
-var NpmRegistryVersionSchema = z13.string().refine(isValidNpmRegistryVersion, {
+var NpmRegistryVersionSchema = z14.string().refine(isValidNpmRegistryVersion, {
   message: "must be a registry dist-tag or semver range"
 });
-var NpmRegistryPackageRequestSchema = z13.object({
+var NpmRegistryPackageRequestSchema = z14.object({
   package: NpmPackageNameSchema,
   version: NpmRegistryVersionSchema.optional()
 }).strict();
 
 // src/schemas/question.ts
-var NpmInstallApprovalDecisionSchema = z14.object({
+var NpmInstallApprovalDecisionSchema = z15.object({
   package: NpmPackageNameSchema,
   version: NpmRegistryVersionSchema,
-  decision: z14.enum(["install", "always", "decline"])
+  decision: z15.enum(["install", "always", "decline"])
 });
-var QuestionAnswerSchema = z14.object({
+var QuestionAnswerSchema = z15.object({
   /** Indices into `choices` the user picked. Empty when only write-in. */
-  selectedChoices: z14.array(z14.number().int().min(0)).optional(),
+  selectedChoices: z15.array(z15.number().int().min(0)).optional(),
   /** Free-text the user typed. Empty when they only clicked choices. */
-  writeIn: z14.string().optional(),
+  writeIn: z15.string().optional(),
   /**
    * Set when the user explicitly dismissed BUT wants the gezel to
    * proceed anyway with sensible defaults. Triggers a synthetic
    * follow-up turn with a `[The user wants you to proceed…]` seed
    * so the gezel knows to make decisions on the user's behalf.
-   * UI label: "Just do whatever".
+   *
+   * The plain question card no longer offers this — a "decide for me"
+   * button next to a question the gezel is blocked on invited the one
+   * answer that teaches it nothing. It stays on the approval cards that
+   * mean it literally (declining an image generation, an npm install,
+   * a schedule) and on the permission broker's dismissal path.
    */
-  declined: z14.boolean().optional(),
+  declined: z15.boolean().optional(),
   /**
    * Set when the user just wants the question to go away — no
    * follow-up turn, no work done, nothing for the gezel to act on.
@@ -2313,97 +2519,112 @@ var QuestionAnswerSchema = z14.object({
    * from `declined` so the model never sees a "user wants defaults"
    * signal that the user didn't intend. UI label: "Skip".
    */
-  silentSkip: z14.boolean().optional(),
+  silentSkip: z15.boolean().optional(),
   /**
    * Per-package decisions for `npm-install-approval` questions. When
    * set, the answer handler installs / always-allows / declines each
    * package and emits a single follow-up summary into the session.
    */
-  npmInstallDecisions: z14.array(NpmInstallApprovalDecisionSchema).optional(),
-  at: z14.string()
+  npmInstallDecisions: z15.array(NpmInstallApprovalDecisionSchema).optional(),
+  at: z15.string()
 });
-var NpmInstallApprovalPackageSchema = z14.object({
+var NpmInstallApprovalPackageSchema = z15.object({
   package: NpmPackageNameSchema,
   version: NpmRegistryVersionSchema
 });
-var CommandApprovalScopeSchema = z14.enum(["script", "npx"]);
-var CommandApprovalInputFileSchema = z14.object({
+var CommandApprovalScopeSchema = z15.enum(["script", "npx"]);
+var CommandApprovalInputFileSchema = z15.object({
   /** Workspace-relative, slash-normalized path shown in the approval prompt. */
-  path: z14.string().min(1),
-  sha256: z14.string().regex(/^[a-f0-9]{64}$/)
+  path: z15.string().min(1),
+  sha256: z15.string().regex(/^[a-f0-9]{64}$/)
 });
-var CommandApprovalIntentSchema = z14.object({
-  kind: z14.literal("command-approval"),
+var CommandApprovalIntentSchema = z15.object({
+  kind: z15.literal("command-approval"),
   scope: CommandApprovalScopeSchema,
-  name: z14.string().min(1),
-  body: z14.string().optional(),
-  args: z14.array(z14.string()).optional(),
-  inputFiles: z14.array(CommandApprovalInputFileSchema).max(128).optional()
-});
-var ToolPermissionIntentSchema = z14.object({
-  kind: z14.literal("tool-permission"),
-  toolName: z14.string(),
-  toolInput: z14.record(z14.string(), z14.unknown())
-});
-var ToolsetInstallApprovalIntentSchema = z14.object({
-  kind: z14.literal("toolset-install-approval"),
-  toolsetId: z14.string(),
-  sourceId: z14.string(),
-  version: z14.string(),
-  targetProjectId: z14.string(),
-  craftbookId: z14.string()
-});
-var ImageGenerationApprovalIntentSchema = z14.object({
-  kind: z14.literal("image-generation-approval"),
-  provider: z14.string(),
-  model: z14.string(),
+  name: z15.string().min(1),
+  body: z15.string().optional(),
+  args: z15.array(z15.string()).optional(),
+  inputFiles: z15.array(CommandApprovalInputFileSchema).max(128).optional()
+});
+var ToolPermissionIntentSchema = z15.object({
+  kind: z15.literal("tool-permission"),
+  toolName: z15.string(),
+  toolInput: z15.record(z15.string(), z15.unknown())
+});
+var ClaudeUserQuestionOptionSchema = z15.object({
+  label: z15.string().min(1),
+  description: z15.string().optional()
+});
+var ClaudeUserQuestionIntentSchema = z15.object({
+  kind: z15.literal("claude-user-question"),
+  /** The CLI's short topic chip for the question (e.g. "Gate block"). */
+  header: z15.string().optional(),
+  /** Options with descriptions; labels mirror the Question's `choices`. */
+  options: z15.array(ClaudeUserQuestionOptionSchema),
+  /** 0-based position within the originating multi-question call. */
+  questionIndex: z15.number().int().min(0),
+  /** Total questions in the originating call (cards appear sequentially). */
+  questionCount: z15.number().int().min(1)
+});
+var ToolsetInstallApprovalIntentSchema = z15.object({
+  kind: z15.literal("toolset-install-approval"),
+  toolsetId: z15.string(),
+  sourceId: z15.string(),
+  version: z15.string(),
+  targetProjectId: z15.string(),
+  craftbookId: z15.string()
+});
+var ImageGenerationApprovalIntentSchema = z15.object({
+  kind: z15.literal("image-generation-approval"),
+  provider: z15.string(),
+  model: z15.string(),
   /** Truncated prompt the model is about to send. Surfaced verbatim. */
-  promptPreview: z14.string(),
+  promptPreview: z15.string(),
   /** Resolved generation size, e.g. '2K 16:9' or '1024x1024'. Optional. */
-  estimatedSize: z14.string().optional()
+  estimatedSize: z15.string().optional()
 });
-var VideoGenerationApprovalIntentSchema = z14.object({
-  kind: z14.literal("video-generation-approval"),
-  provider: z14.string(),
-  model: z14.string(),
-  promptPreview: z14.string(),
+var VideoGenerationApprovalIntentSchema = z15.object({
+  kind: z15.literal("video-generation-approval"),
+  provider: z15.string(),
+  model: z15.string(),
+  promptPreview: z15.string(),
   /** Resolved clip shape, e.g. '704×480 · 97f · 24fps'. Optional. */
-  estimatedSize: z14.string().optional()
+  estimatedSize: z15.string().optional()
 });
-var ScheduleApprovalIntentSchema = z14.object({
-  kind: z14.literal("schedule-approval"),
-  typeId: z14.string(),
-  craftbookId: z14.string(),
+var ScheduleApprovalIntentSchema = z15.object({
+  kind: z15.literal("schedule-approval"),
+  typeId: z15.string(),
+  craftbookId: z15.string(),
   /**
    * Recurrence flavor. Absent → 'scheduled' (every question written
    * before this field existed is a cron schedule). 'night-shift' hosts
    * run inside the Night Shift window instead of on a user-visible cron;
    * the card copy switches accordingly.
    */
-  runMode: z14.enum(["scheduled", "night-shift"]).optional(),
+  runMode: z15.enum(["scheduled", "night-shift"]).optional(),
   /**
    * 5-field cron expression (UTC). Surfaced verbatim on the card for
    * 'scheduled' hosts; for 'night-shift' hosts it is the internal
    * heartbeat and the card shows the window instead.
    */
-  cron: z14.string(),
-  overlap: z14.enum(["skip", "queue", "concurrent"]).optional()
+  cron: z15.string(),
+  overlap: z15.enum(["skip", "queue", "concurrent"]).optional()
 });
-var NightShiftReviewIntentSchema = z14.object({
-  kind: z14.literal("night-shift-review"),
+var NightShiftReviewIntentSchema = z15.object({
+  kind: z15.literal("night-shift-review"),
   /** The window's day key (see `nightShiftWindowKey`). */
-  windowKey: z14.string(),
-  tasksCompleted: z14.number(),
-  reports: z14.array(
-    z14.object({
-      projectId: z14.string(),
-      path: z14.string(),
-      title: z14.string().optional(),
-      actionCount: z14.number()
+  windowKey: z15.string(),
+  tasksCompleted: z15.number(),
+  reports: z15.array(
+    z15.object({
+      projectId: z15.string(),
+      path: z15.string(),
+      title: z15.string().optional(),
+      actionCount: z15.number()
     })
   )
 });
-var TaskPausedReasonSchema = z14.enum([
+var TaskPausedReasonSchema = z15.enum([
   "gate_exhausted",
   "gate_plateau",
   "gate_unsatisfiable",
@@ -2411,25 +2632,26 @@ var TaskPausedReasonSchema = z14.enum([
   "step_stalled",
   "budget_exhausted"
 ]);
-var TaskPausedIntentSchema = z14.object({
-  kind: z14.literal("task-paused"),
+var TaskPausedIntentSchema = z15.object({
+  kind: z15.literal("task-paused"),
   /** `projectId/num` of the paused task — the dedup key. */
-  taskRef: z14.string(),
-  stepId: z14.string().optional(),
+  taskRef: z15.string(),
+  stepId: z15.string().optional(),
   reason: TaskPausedReasonSchema
 });
-var QuestionIntentSchema = z14.discriminatedUnion("kind", [
-  z14.object({
-    kind: z14.literal("npm-install-approval"),
+var QuestionIntentSchema = z15.discriminatedUnion("kind", [
+  z15.object({
+    kind: z15.literal("npm-install-approval"),
     /**
      * Packages that need approval. Always at least one; multiple when
      * the gezel batched an install call (encouraged) or when we merged
      * a later request into the same pending question for dedup.
      */
-    packages: z14.array(NpmInstallApprovalPackageSchema).min(1)
+    packages: z15.array(NpmInstallApprovalPackageSchema).min(1)
   }),
   CommandApprovalIntentSchema,
   ToolPermissionIntentSchema,
+  ClaudeUserQuestionIntentSchema,
   ToolsetInstallApprovalIntentSchema,
   ImageGenerationApprovalIntentSchema,
   VideoGenerationApprovalIntentSchema,
@@ -2437,61 +2659,61 @@ var QuestionIntentSchema = z14.discriminatedUnion("kind", [
   NightShiftReviewIntentSchema,
   TaskPausedIntentSchema
 ]);
-var QuestionSchema = z14.object({
-  id: z14.string(),
-  projectId: z14.string(),
-  gezelId: z14.string(),
-  sessionId: z14.string(),
+var QuestionSchema = z15.object({
+  id: z15.string(),
+  projectId: z15.string(),
+  gezelId: z15.string(),
+  sessionId: z15.string(),
   /** Body of the question — supports markdown. */
-  prompt: z14.string().min(1),
+  prompt: z15.string().min(1),
   /** Optional preset choices. Empty / omitted => write-in only. */
-  choices: z14.array(z14.string()).max(20).optional(),
+  choices: z15.array(z15.string()).max(20).optional(),
   /** Whether the user can also type a write-in alongside choices. Default true. */
-  allowWriteIn: z14.boolean().optional(),
+  allowWriteIn: z15.boolean().optional(),
   /** Whether multiple choices may be selected. Default false. */
-  multiSelect: z14.boolean().optional(),
+  multiSelect: z15.boolean().optional(),
   /**
    * Approval-flow attachment: a task this question is *about*. Stored in
    * `projectId/num` form so existing parsing helpers work. The UI shows
    * the task title + status above the prompt and offers an "Open task"
    * link.
    */
-  taskRef: z14.string().optional(),
+  taskRef: z15.string().optional(),
   /**
    * Approval-flow attachment: a document this question is *about*.
    * Project-relative path when `projectId` is set, otherwise into the
    * global `~/.gezel/documents/` library. The UI renders a collapsed
    * preview + "Open document" link.
    */
-  documentPath: z14.string().optional(),
+  documentPath: z15.string().optional(),
   /**
    * Service-created specialized-question marker (see `QuestionIntent`
    * for context). Absent for plain user-facing questions asked via
    * the `ask_user_question` MCP tool.
    */
   intent: QuestionIntentSchema.optional(),
-  createdAt: z14.string(),
+  createdAt: z15.string(),
   /** Set once the user has answered (or declined). */
   answer: QuestionAnswerSchema.optional()
 });
 
 // src/schemas/recognition.ts
-import { z as z15 } from "zod";
-var ImageExifSchema = z15.object({
-  make: z15.string().optional(),
-  model: z15.string().optional(),
-  lensModel: z15.string().optional(),
-  dateTimeOriginal: z15.string().optional(),
-  orientation: z15.number().int().min(1).max(8).optional(),
-  software: z15.string().optional(),
-  imageDescription: z15.string().optional()
-});
-var ImageStaticMetaSchema = z15.object({
-  format: z15.enum(["png", "jpeg", "gif", "webp", "svg", "unknown"]),
-  width: z15.number().int().positive().optional(),
-  height: z15.number().int().positive().optional(),
-  byteLength: z15.number().int().nonnegative(),
-  sha256: z15.string().regex(/^[a-f0-9]{64}$/),
+import { z as z16 } from "zod";
+var ImageExifSchema = z16.object({
+  make: z16.string().optional(),
+  model: z16.string().optional(),
+  lensModel: z16.string().optional(),
+  dateTimeOriginal: z16.string().optional(),
+  orientation: z16.number().int().min(1).max(8).optional(),
+  software: z16.string().optional(),
+  imageDescription: z16.string().optional()
+});
+var ImageStaticMetaSchema = z16.object({
+  format: z16.enum(["png", "jpeg", "gif", "webp", "svg", "unknown"]),
+  width: z16.number().int().positive().optional(),
+  height: z16.number().int().positive().optional(),
+  byteLength: z16.number().int().nonnegative(),
+  sha256: z16.string().regex(/^[a-f0-9]{64}$/),
   /**
    * PNG `tEXt`/`iTXt`/`zTXt` keyword→value pairs. Generation provenance lives
    * here (A1111 writes `parameters`, ComfyUI writes `prompt`/`workflow`) and
@@ -2500,153 +2722,171 @@ var ImageStaticMetaSchema = z15.object({
    * Attacker-controlled: anyone can author a PNG whose `Description` chunk
    * reads "Ignore previous instructions". Renderers MUST fence and cap this.
    */
-  pngText: z15.record(z15.string(), z15.string()).optional(),
+  pngText: z16.record(z16.string(), z16.string()).optional(),
   exif: ImageExifSchema.optional(),
   /** Withheld from every prompt. See the schema doc above. */
-  gps: z15.object({ lat: z15.number(), lon: z15.number() }).optional(),
+  gps: z16.object({ lat: z16.number(), lon: z16.number() }).optional(),
   /** True when the file carried location data we deliberately dropped. */
-  gpsRedacted: z15.boolean().optional(),
+  gpsRedacted: z16.boolean().optional(),
   /**
    * Heuristic from dimensions, format, and metadata — drives `auto` mode
    * selection without paying a classifier call.
    */
-  likelyScreenshot: z15.boolean().optional()
+  likelyScreenshot: z16.boolean().optional()
 });
-var RecognitionModeSchema = z15.enum(["describe", "ocr", "ui", "extract"]);
-var RecognitionModeRequestSchema = z15.enum(["auto", "describe", "ocr", "ui", "extract"]);
-var ImageRecognitionSchema = z15.object({
-  schemaVersion: z15.literal(1),
-  sha256: z15.string().regex(/^[a-f0-9]{64}$/),
+var RecognitionModeSchema = z16.enum(["describe", "ocr", "ui", "extract"]);
+var RecognitionModeRequestSchema = z16.enum(["auto", "describe", "ocr", "ui", "extract"]);
+var ImageRecognitionSchema = z16.object({
+  schemaVersion: z16.literal(1),
+  sha256: z16.string().regex(/^[a-f0-9]{64}$/),
   meta: ImageStaticMetaSchema,
-  modes: z15.array(RecognitionModeSchema).min(1),
-  description: z15.string().optional(),
-  ocrText: z15.string().optional(),
-  structured: z15.object({
-    templateId: z15.string().optional(),
-    data: z15.unknown()
+  modes: z16.array(RecognitionModeSchema).min(1),
+  description: z16.string().optional(),
+  ocrText: z16.string().optional(),
+  structured: z16.object({
+    templateId: z16.string().optional(),
+    data: z16.unknown()
   }).optional(),
-  engine: z15.enum(["llama-cpp", "mlx", "mock", "none"]),
-  modelId: z15.string(),
-  status: z15.enum(["ok", "partial", "failed", "static-only"]),
-  failureReason: z15.string().optional(),
-  durationMs: z15.number().int().nonnegative(),
-  at: z15.string()
+  engine: z16.enum(["llama-cpp", "mlx", "mock", "none"]),
+  modelId: z16.string(),
+  status: z16.enum(["ok", "partial", "failed", "static-only"]),
+  failureReason: z16.string().optional(),
+  durationMs: z16.number().int().nonnegative(),
+  at: z16.string()
 });
-var MessageImageDigestSchema = z15.object({
+var MessageImageDigestSchema = z16.object({
   /** The markdown ref exactly as it appears in the message body. */
-  ref: z15.string(),
-  sha256: z15.string().regex(/^[a-f0-9]{64}$/),
+  ref: z16.string(),
+  sha256: z16.string().regex(/^[a-f0-9]{64}$/),
   /** Pre-rendered, already capped and fenced-safe. */
-  digest: z15.string(),
-  modelId: z15.string(),
-  modes: z15.array(RecognitionModeSchema),
-  status: z15.enum(["ok", "partial", "failed", "static-only"]),
-  at: z15.string()
+  digest: z16.string(),
+  modelId: z16.string(),
+  modes: z16.array(RecognitionModeSchema),
+  status: z16.enum(["ok", "partial", "failed", "static-only"]),
+  at: z16.string()
 });
-var RecognitionRequestSchema = z15.object({
+var RecognitionRequestSchema = z16.object({
   /** Project-relative artifact path, e.g. `attachments/<uuid>.png`. */
-  artifactPath: z15.string().min(1).optional(),
-  data: z15.string().min(1).optional(),
-  mimeType: z15.string().optional(),
+  artifactPath: z16.string().min(1).optional(),
+  data: z16.string().min(1).optional(),
+  mimeType: z16.string().optional(),
   mode: RecognitionModeRequestSchema.default("auto"),
   /** JSON Schema for `extract` mode — fed to llama-server `response_format`. */
-  schema: z15.unknown().optional(),
+  schema: z16.unknown().optional(),
   /** Overrides the configured recognition model for this call. */
-  model: z15.string().optional()
+  model: z16.string().optional()
 });
-var RecognitionHealthSchema = z15.object({
-  state: z15.enum(["ok", "no-model", "not-configured", "error"]),
-  modelId: z15.string().optional(),
-  detail: z15.string().optional()
+var RecognitionHealthSchema = z16.object({
+  state: z16.enum(["ok", "no-model", "not-configured", "error"]),
+  modelId: z16.string().optional(),
+  detail: z16.string().optional()
 });
-var RecognitionPullEventSchema = z15.union([
-  z15.object({
-    type: z15.literal("progress"),
-    bytesWritten: z15.number().int().nonnegative(),
-    totalBytes: z15.number().int().nonnegative().optional()
+var RecognitionPullEventSchema = z16.union([
+  z16.object({
+    type: z16.literal("progress"),
+    bytesWritten: z16.number().int().nonnegative(),
+    totalBytes: z16.number().int().nonnegative().optional()
   }),
-  z15.object({ type: z15.literal("error"), error: z15.string() }),
-  z15.object({ type: z15.literal("done"), id: z15.string() })
+  z16.object({ type: z16.literal("error"), error: z16.string() }),
+  z16.object({ type: z16.literal("done"), id: z16.string() })
 ]);
-var RecognitionCatalogEntrySchema = z15.object({
-  id: z15.string(),
-  name: z15.string(),
-  description: z15.string(),
-  license: z15.string(),
-  approxSizeBytes: z15.number().int().nonnegative(),
-  recoScore: z15.number()
+var RecognitionCatalogEntrySchema = z16.object({
+  id: z16.string(),
+  name: z16.string(),
+  description: z16.string(),
+  license: z16.string(),
+  approxSizeBytes: z16.number().int().nonnegative(),
+  recoScore: z16.number()
 });
-var ListRecognitionCatalogResponseSchema = z15.object({
-  models: z15.array(RecognitionCatalogEntrySchema)
+var ListRecognitionCatalogResponseSchema = z16.object({
+  models: z16.array(RecognitionCatalogEntrySchema)
 });
-var InstalledRecognitionModelSchema = z15.object({
-  id: z15.string(),
-  name: z15.string(),
-  approxSizeBytes: z15.number().int().nonnegative(),
-  installedAt: z15.string(),
-  weightsPath: z15.string().optional(),
-  mmprojPath: z15.string().optional()
+var InstalledRecognitionModelSchema = z16.object({
+  id: z16.string(),
+  name: z16.string(),
+  approxSizeBytes: z16.number().int().nonnegative(),
+  installedAt: z16.string(),
+  weightsPath: z16.string().optional(),
+  mmprojPath: z16.string().optional()
+});
+var ListInstalledRecognitionModelsResponseSchema = z16.object({
+  models: z16.array(InstalledRecognitionModelSchema)
+});
+
+// src/schemas/session-lineage.ts
+import { z as z17 } from "zod";
+var SessionLinkSchema = z17.object({
+  sessionId: z17.string(),
+  gezelId: z17.string()
 });
-var ListInstalledRecognitionModelsResponseSchema = z15.object({
-  models: z15.array(InstalledRecognitionModelSchema)
+var SessionParentSchema = SessionLinkSchema.extend({
+  kind: z17.enum(["delegation", "consultation", "task-entry", "task-handoff"])
 });
 
 // src/schemas/session-telemetry.ts
-import { z as z16 } from "zod";
-var SessionGpuTaskSchema = z16.enum([
+import { z as z18 } from "zod";
+var SessionGpuTaskSchema = z18.enum([
   "image_generation",
   "video_generation",
   "image_recognition"
 ]);
-var SessionTurnTelemetrySchema = z16.object({
+var SessionTurnPhaseSchema = z18.enum(["preparing", "recall", "provider"]);
+var SessionTurnTelemetrySchema = z18.object({
   /** Epoch ms when the in-flight turn started. */
-  startedAt: z16.number(),
-  streamedContentChars: z16.number().int().nonnegative(),
-  toolCalls: z16.number().int().nonnegative(),
-  fileMutations: z16.number().int().nonnegative()
-});
-var SessionTelemetrySchema = z16.object({
-  sessionId: z16.string(),
-  gezelId: z16.string(),
-  projectId: z16.string(),
+  startedAt: z18.number(),
+  phase: SessionTurnPhaseSchema,
+  /** Epoch ms when `phase` last changed. */
+  phaseStartedAt: z18.number(),
+  /** Provider requests issued by this user-visible turn, including retries. */
+  providerRequestsStarted: z18.number().int().nonnegative(),
+  streamedContentChars: z18.number().int().nonnegative(),
+  toolCalls: z18.number().int().nonnegative(),
+  fileMutations: z18.number().int().nonnegative()
+});
+var SessionTelemetrySchema = z18.object({
+  sessionId: z18.string(),
+  gezelId: z18.string(),
+  projectId: z18.string(),
   /** True while a send is currently running for this session. */
-  inflight: z16.boolean(),
-  turnsStarted: z16.number().int().nonnegative(),
-  deltaChunks: z16.number().int().nonnegative(),
-  streamedContentChars: z16.number().int().nonnegative(),
-  wirePulses: z16.number().int().nonnegative(),
-  heartbeats: z16.number().int().nonnegative(),
-  enginePhaseEvents: z16.number().int().nonnegative(),
+  inflight: z18.boolean(),
+  turnsStarted: z18.number().int().nonnegative(),
+  /** Provider requests issued across all turns in this daemon process. */
+  providerRequestsStarted: z18.number().int().nonnegative(),
+  deltaChunks: z18.number().int().nonnegative(),
+  streamedContentChars: z18.number().int().nonnegative(),
+  wirePulses: z18.number().int().nonnegative(),
+  heartbeats: z18.number().int().nonnegative(),
+  enginePhaseEvents: z18.number().int().nonnegative(),
   /**
    * `engine_phase === 'generating'` transitions — roughly one per completion
    * request the engine served (the slot-launch granularity stall logic and
    * the eval chatter threshold were calibrated against).
    */
-  generationSpurts: z16.number().int().nonnegative(),
-  toolCalls: z16.number().int().nonnegative(),
-  toolArgChars: z16.number().int().nonnegative(),
-  fileMutations: z16.number().int().nonnegative(),
-  gpuEvents: z16.number().int().nonnegative(),
+  generationSpurts: z18.number().int().nonnegative(),
+  toolCalls: z18.number().int().nonnegative(),
+  toolArgChars: z18.number().int().nonnegative(),
+  fileMutations: z18.number().int().nonnegative(),
+  gpuEvents: z18.number().int().nonnegative(),
   gpuTaskActive: SessionGpuTaskSchema.nullable(),
   /** Epoch ms of the last streamed signal (delta / pulse / heartbeat / phase). */
-  lastStreamActivityAt: z16.number().nullable(),
-  lastToolActivityAt: z16.number().nullable(),
-  lastMutationAt: z16.number().nullable(),
-  lastGpuActivityAt: z16.number().nullable(),
+  lastStreamActivityAt: z18.number().nullable(),
+  lastToolActivityAt: z18.number().nullable(),
+  lastMutationAt: z18.number().nullable(),
+  lastGpuActivityAt: z18.number().nullable(),
   /** Max of all activity timestamps — "when did ANY progress signal last fire". */
-  lastProgressAt: z16.number().nullable(),
+  lastProgressAt: z18.number().nullable(),
   /** Counters scoped to the currently-running turn; null between turns. */
   currentTurn: SessionTurnTelemetrySchema.nullable()
 });
-var SessionTelemetryListResponseSchema = z16.object({
+var SessionTelemetryListResponseSchema = z18.object({
   /** Bumped when counter semantics change; consumers gate on it. */
-  version: z16.literal(1),
-  capturedAt: z16.number(),
-  sessions: z16.array(SessionTelemetrySchema)
+  version: z18.literal(1),
+  capturedAt: z18.number(),
+  sessions: z18.array(SessionTelemetrySchema)
 });
 
 // src/schemas/gezel.ts
-var ProviderNameSchema = z17.enum([
+var ProviderNameSchema = z19.enum([
   "copilot",
   "openai",
   "anthropic",
@@ -2668,27 +2908,27 @@ var ProviderNameSchema = z17.enum([
   // forward-pass is remoted — so `remote` is NOT a local provider.
   "remote"
 ]);
-var GezelGenderSchema = z17.enum(["male", "female", "non-binary"]);
-var FixedFunctionConfigSchema = z17.object({
+var GezelGenderSchema = z19.enum(["male", "female", "non-binary"]);
+var FixedFunctionConfigSchema = z19.object({
   /** MCP tool name to forward to (e.g. `'generate_image'`). */
-  tool: z17.string().min(1),
+  tool: z19.string().min(1),
   /** Argument key on the tool that receives the user's message text. */
-  promptKey: z17.string().min(1).default("prompt"),
+  promptKey: z19.string().min(1).default("prompt"),
   /** Defaults merged into every call; user text on `promptKey` always wins. */
-  defaults: z17.record(z17.string(), z17.unknown()).optional()
+  defaults: z19.record(z19.string(), z19.unknown()).optional()
 });
-var GezelTraitSchema = z17.object({
-  id: z17.string(),
+var GezelTraitSchema = z19.object({
+  id: z19.string(),
   /** One imperative second-person sentence, rendered as a prompt bullet. */
-  text: z17.string().min(1).max(200),
-  adoptedAt: z17.string(),
-  source: z17.enum(["levelup", "manual"]).optional()
+  text: z19.string().min(1).max(200),
+  adoptedAt: z19.string(),
+  source: z19.enum(["levelup", "manual"]).optional()
 });
-var GezelFrontmatterSchema = z17.object({
+var GezelFrontmatterSchema = z19.object({
   id: EntityIdSchema.optional(),
-  name: z17.string(),
-  description: z17.string().optional(),
-  role: z17.string().optional(),
+  name: z19.string(),
+  description: z19.string().optional(),
+  role: z19.string().optional(),
   /**
    * Kebab-case slug derived from `role` (or `gezel-N` when role is absent),
    * globally unique across the install. Collisions get `-2`, `-3`, …
@@ -2696,7 +2936,7 @@ var GezelFrontmatterSchema = z17.object({
    * identifier for @-mentions and as the sole rendered identifier when
    * `config.roleBasedNameOnlyMode` is enabled.
    */
-  roleBasedName: z17.string().optional(),
+  roleBasedName: z19.string().optional(),
   /**
    * One of `male` / `female` / `non-binary`. Assigned at creation time
    * from the matching gendered first-name pool (with a small chance of
@@ -2705,9 +2945,9 @@ var GezelFrontmatterSchema = z17.object({
    * own prompt. Absent on legacy gezels, where references omit pronouns.
    */
   gender: GezelGenderSchema.optional(),
-  model: z17.string().optional(),
+  model: z19.string().optional(),
   provider: ProviderNameSchema.optional(),
-  reasoningEffort: z17.string().optional(),
+  reasoningEffort: z19.string().optional(),
   /**
    * Per-gezel sampling / reasoning / structured-output / tool-call overrides.
    * Sparse — only set fields override the catalog's recommended defaults.
@@ -2740,8 +2980,8 @@ var GezelFrontmatterSchema = z17.object({
    * low-temperature `thinking-precise` without locking the user out.
    */
   suggestedTuningProfile: TuningProfileIdSchema.optional(),
-  tools: z17.array(z17.string()).optional(),
-  tags: z17.array(z17.string()).optional(),
+  tools: z19.array(z19.string()).optional(),
+  tags: z19.array(z19.string()).optional(),
   /**
    * When set, switches this gezel into "fixed-function" mode: chat
    * messages bypass the LLM and forward to the named MCP tool. See
@@ -2751,14 +2991,20 @@ var GezelFrontmatterSchema = z17.object({
    */
   fixedFunction: FixedFunctionConfigSchema.optional(),
   /** Ollama-only: override the context window (tokens) for this gezel. */
-  numCtx: z17.number().int().positive().optional(),
+  numCtx: z19.number().int().positive().optional(),
   /** When false, suppresses auto-recall on session start for this gezel. */
-  autoRecall: z17.boolean().optional(),
+  autoRecall: z19.boolean().optional(),
+  /**
+   * Per-gezel proactive indexed-context policy. Supersedes `autoRecall` when
+   * present; absent inherits the install default. The generic `search` tool is
+   * still available in `off` mode.
+   */
+  retrieval: RetrievalPolicySchema.optional(),
   /**
    * Chat bubble font id (one of `GEZEL_CHAT_FONTS[*].id`). When unset or
    * unrecognized, chat bubbles inherit the app default (Hanken Grotesk).
    */
-  font: z17.string().optional(),
+  font: z19.string().optional(),
   /**
    * Kokoro TTS voice id (one of `KOKORO_VOICES[*].id`, e.g. `af_heart`,
    * `bm_george`). Drives spoken audio rendering — `synthesize_speech`
@@ -2767,7 +3013,7 @@ var GezelFrontmatterSchema = z17.object({
    * dialog. Absent on legacy gezels — synthesize falls back to the
    * default voice (`af_heart`) when missing.
    */
-  voice: z17.string().optional(),
+  voice: z19.string().optional(),
   /**
    * Provenance: the id of the gilde catalog template this gezel was
    * created from, if any. Written by exact-template or about-omitted
@@ -2775,7 +3021,7 @@ var GezelFrontmatterSchema = z17.object({
    * Absent on bespoke-generated or hand-authored gezels. The UI uses
    * this to offer "reset to original template" on the about editor.
    */
-  templateId: z17.string().optional(),
+  templateId: z19.string().optional(),
   /**
    * Provenance: the semver of the template version installed at create
    * time. Paired with `templateId`. Absent on gezels created before this
@@ -2783,7 +3029,7 @@ var GezelFrontmatterSchema = z17.object({
    * source version" and offers a refresh to current latest without
    * comparing.
    */
-  templateVersion: z17.string().optional(),
+  templateVersion: z19.string().optional(),
   /**
    * Copilot-only: when true, deny the Copilot CLI's built-in tools
    * (bash, web_fetch, view, str_replace_editor, read_file, write_file,
@@ -2792,7 +3038,7 @@ var GezelFrontmatterSchema = z17.object({
    * itself defaults to the sandboxed MCP surface.
    * Provider other than copilot: ignored.
    */
-  sandboxCopilot: z17.boolean().optional(),
+  sandboxCopilot: z19.boolean().optional(),
   /**
    * `anthropic-cli`-only: per-gezel override for the Claude CLI permission
    * mode. Forwarded as `--permission-mode <value>` to each `claude` invocation.
@@ -2818,7 +3064,7 @@ var GezelFrontmatterSchema = z17.object({
    * abstract sigil instead of the parametric poppetje. Default (absent /
    * false) renders the poppetje everywhere. Toggled from Gezel Detail.
    */
-  iconOverride: z17.boolean().optional(),
+  iconOverride: z19.boolean().optional(),
   /**
    * Standing behavior traits, adopted through the growth system (or
    * hand-authored). Rendered as their own `### Traits` block in the
@@ -2827,7 +3073,7 @@ var GezelFrontmatterSchema = z17.object({
    * The frontmatter list is AUTHORITATIVE for what's active — growth.json
    * keeps the evidence-bearing adoption log.
    */
-  traits: z17.array(GezelTraitSchema).max(8).optional(),
+  traits: z19.array(GezelTraitSchema).max(8).optional(),
   /**
    * Overrides `config.recognition.mode` for this gezel. A gezel whose job is
    * reading screenshots sets `always`; everyone else inherits.
@@ -2837,46 +3083,48 @@ var GezelFrontmatterSchema = z17.object({
    * support burden. Native vision is a property of the model *install*, not of
    * the gezel, so it has no frontmatter counterpart.
    */
-  recognition: z17.enum(["auto", "always", "off"]).optional()
+  recognition: z19.enum(["auto", "always", "off"]).optional()
 });
-var GezelSectionSchema = z17.object({
-  heading: z17.string(),
-  template: z17.string().optional(),
-  params: z17.record(z17.string(), z17.string()).optional(),
-  body: z17.string()
+var GezelSectionSchema = z19.object({
+  heading: z19.string(),
+  template: z19.string().optional(),
+  params: z19.record(z19.string(), z19.string()).optional(),
+  body: z19.string()
 });
-var ParsedGezelSchema = z17.object({
+var ParsedGezelSchema = z19.object({
   frontmatter: GezelFrontmatterSchema,
-  sections: z17.array(GezelSectionSchema),
-  source: z17.string()
+  sections: z19.array(GezelSectionSchema),
+  source: z19.string()
 });
-var GezelSummarySchema = z17.object({
+var GezelSummarySchema = z19.object({
   id: EntityIdSchema,
-  name: z17.string(),
-  description: z17.string().optional(),
-  role: z17.string().optional(),
+  name: z19.string(),
+  description: z19.string().optional(),
+  role: z19.string().optional(),
   /** Mirrors `GezelFrontmatter.roleBasedName`. */
-  roleBasedName: z17.string().optional(),
+  roleBasedName: z19.string().optional(),
   /** Mirrors `GezelFrontmatter.gender`. */
   gender: GezelGenderSchema.optional(),
-  model: z17.string().optional(),
+  model: z19.string().optional(),
   provider: ProviderNameSchema.optional(),
-  reasoningEffort: z17.string().optional(),
+  reasoningEffort: z19.string().optional(),
   /** Mirrors `GezelFrontmatter.tuningProfile`. */
   tuningProfile: TuningProfileIdSchema.optional(),
   /** Mirrors `GezelFrontmatter.suggestedTuningProfile`. */
   suggestedTuningProfile: TuningProfileIdSchema.optional(),
-  numCtx: z17.number().int().positive().optional(),
-  autoRecall: z17.boolean().optional(),
-  font: z17.string().optional(),
+  numCtx: z19.number().int().positive().optional(),
+  autoRecall: z19.boolean().optional(),
+  /** Mirrors `GezelFrontmatter.retrieval`. */
+  retrieval: RetrievalPolicySchema.optional(),
+  font: z19.string().optional(),
   /** Mirrors `GezelFrontmatter.voice` — Kokoro TTS voice id. */
-  voice: z17.string().optional(),
+  voice: z19.string().optional(),
   /** Mirrors `GezelFrontmatter.templateId` when the gezel came from a gilde template. */
-  templateId: z17.string().optional(),
+  templateId: z19.string().optional(),
   /** Mirrors `GezelFrontmatter.templateVersion`. */
-  templateVersion: z17.string().optional(),
+  templateVersion: z19.string().optional(),
   /** Mirrors `GezelFrontmatter.sandboxCopilot`. */
-  sandboxCopilot: z17.boolean().optional(),
+  sandboxCopilot: z19.boolean().optional(),
   /** Mirrors `GezelFrontmatter.claudePermissionMode`. */
   claudePermissionMode: ClaudePermissionModeSchema.optional(),
   /** Mirrors `GezelFrontmatter.codexPermissionMode`. */
@@ -2889,7 +3137,7 @@ var GezelSummarySchema = z17.object({
    * affordance.
    */
   fixedFunction: FixedFunctionConfigSchema.optional(),
-  icon: z17.string().optional(),
+  icon: z19.string().optional(),
   /**
    * The resolved poppetje character data for this gezel. Inlined on
    * every list/detail response so the UI can render the parametric SVG
@@ -2899,9 +3147,9 @@ var GezelSummarySchema = z17.object({
    */
   poppetje: PoppetjeSchema.optional(),
   /** Mirrors `GezelFrontmatter.iconOverride`. */
-  iconOverride: z17.boolean().optional(),
+  iconOverride: z19.boolean().optional(),
   /** Mirrors `GezelFrontmatter.recognition`. */
-  recognition: z17.enum(["auto", "always", "off"]).optional(),
+  recognition: z19.enum(["auto", "always", "off"]).optional(),
   /**
    * Where this gezel lives. `global` (the default when absent — back-compat
    * with every gezel on disk before this field existed) is the install-wide
@@ -2911,15 +3159,15 @@ var GezelSummarySchema = z17.object({
    * badges project-scoped gezels and the roster only surfaces them inside
    * their own project.
    */
-  scope: z17.enum(["global", "project"]).optional(),
+  scope: z19.enum(["global", "project"]).optional(),
   /**
    * Filesystem ownership boundary, distinct from `scope` above. Shared gezel
    * identity lives in the installer-managed machine root; chats, memories,
    * growth, credentials, and installed toolsets remain in the user home.
    */
-  storageScope: z17.enum(["user", "machine-shared"]).optional(),
+  storageScope: z19.enum(["user", "machine-shared"]).optional(),
   /** Mirrors `GezelFrontmatter.traits`. */
-  traits: z17.array(GezelTraitSchema).optional(),
+  traits: z19.array(GezelTraitSchema).optional(),
   /**
    * Lightweight growth summary (level + pending level-up flag),
    * hydrated from growth.json and inlined on list/detail responses —
@@ -2927,11 +3175,11 @@ var GezelSummarySchema = z17.object({
    * without N+1 follow-up requests.
    */
   growth: GezelGrowthSummarySchema.optional(),
-  updatedAt: z17.string()
+  updatedAt: z19.string()
 });
 var GezelDetailSchema = GezelSummarySchema.extend({
   parsed: ParsedGezelSchema,
-  about: z17.string(),
+  about: z19.string(),
   /**
    * Optional contents of the per-gezel `tools.md` file. When present
    * (non-null), fully replaces the auto-injected `## Tools available
@@ -2941,43 +3189,87 @@ var GezelDetailSchema = GezelSummarySchema.extend({
    * default) means no override file exists and the runtime renders
    * the auto-block from the live MCP bridge.
    */
-  toolsMd: z17.string().nullable().default(null)
+  toolsMd: z19.string().nullable().default(null)
 });
-var ToolCallImageSchema = z17.object({
+var ToolCallImageSchema = z19.object({
   /** Path relative to the project's artifacts/ root (e.g. `sessions/2026-04-19_143015_snake-test/tool-3-img-0.png`). */
-  path: z17.string(),
+  path: z19.string(),
   /** MIME type of the image, used by the UI to set the right `<img>` src URL. */
-  mimeType: z17.string()
+  mimeType: z19.string()
 });
-var ToolCallAudioSchema = z17.object({
+var ToolCallAudioSchema = z19.object({
   /** Path relative to the project's artifacts/ root. */
-  path: z17.string(),
+  path: z19.string(),
   /** MIME type, e.g. `audio/wav`. */
-  mimeType: z17.string(),
+  mimeType: z19.string(),
   /** Duration in seconds when known — used by the UI to show length without preloading the blob. */
-  durationSeconds: z17.number().optional(),
+  durationSeconds: z19.number().optional(),
   /** Voice id used to produce this audio (TTS only). */
-  voice: z17.string().optional()
+  voice: z19.string().optional()
 });
-var ToolCallVideoSchema = z17.object({
+var ToolCallVideoSchema = z19.object({
   /** Path relative to the project's artifacts/ root (e.g. `generated/video-123.mp4`). */
-  path: z17.string(),
+  path: z19.string(),
   /** MIME type, e.g. `video/mp4`. */
-  mimeType: z17.string(),
+  mimeType: z19.string(),
   /** Optional poster-frame artifact path for the `<video poster>` attribute. */
-  posterPath: z17.string().optional()
+  posterPath: z19.string().optional()
 });
-var ChatMessageToolCallSchema = z17.object({
-  name: z17.string(),
-  durationMs: z17.number(),
-  success: z17.boolean(),
-  errorMessage: z17.string().optional(),
+var ToolCardStepSchema = z19.object({
+  id: z19.string(),
+  name: z19.string(),
+  status: z19.enum(["done", "active", "pending"])
+});
+var CraftbookStartCardSchema = z19.object({
+  kind: z19.literal("craftbook-start"),
+  craftbookId: z19.string(),
+  craftbookName: z19.string(),
+  /** Task ref `projectId/num`. */
+  taskRef: z19.string(),
+  /** The TASK's project — may differ from the session's when invoked cross-project. */
+  projectId: z19.string(),
+  /** Task status at event time. */
+  status: z19.string(),
+  activeStepId: z19.string().optional(),
+  steps: z19.array(ToolCardStepSchema),
+  /** True when the call idempotently returned an already-running task. */
+  reused: z19.boolean().optional(),
+  /**
+   * The craftbook declares it works better with the External services
+   * capability. The UI nudges (with the optional author rationale) only
+   * while the resolved security policy has it disabled.
+   */
+  recommendsExternalServices: z19.object({ reason: z19.string().optional() }).optional()
+});
+var TaskStepAdvanceCardSchema = z19.object({
+  kind: z19.literal("task-step-advance"),
+  craftbookId: z19.string(),
+  craftbookName: z19.string(),
+  taskRef: z19.string(),
+  projectId: z19.string(),
+  status: z19.string(),
+  completedStepId: z19.string(),
+  completedStepName: z19.string().optional(),
+  /** Absent when the advance took the task terminal (complete/canceled). */
+  activeStepId: z19.string().optional(),
+  activeStepName: z19.string().optional(),
+  steps: z19.array(ToolCardStepSchema)
+});
+var ToolCallCardSchema = z19.discriminatedUnion("kind", [
+  CraftbookStartCardSchema,
+  TaskStepAdvanceCardSchema
+]);
+var ChatMessageToolCallSchema = z19.object({
+  name: z19.string(),
+  durationMs: z19.number(),
+  success: z19.boolean(),
+  errorMessage: z19.string().optional(),
   /** File path the tool touched, for the References pane. */
-  path: z17.string().optional(),
+  path: z19.string().optional(),
   /** Ordered file paths touched by a batched filesystem tool. */
-  paths: z17.array(z17.string()).optional(),
+  paths: z19.array(z19.string()).optional(),
   /** Compact, human-readable one-liner ("→ Freja: update the game loop · file: workspace/index.html"). */
-  argsSummary: z17.string().optional(),
+  argsSummary: z19.string().optional(),
   /**
    * The tool call's FULL arguments, rendered as readable text (field by
    * field, bulky values shown in full — not truncated like
@@ -2988,60 +3280,132 @@ var ChatMessageToolCallSchema = z17.object({
    * arguments are not a secret vector in this codebase (secrets live in
    * the toolset-config path), so this is not separately redacted.
    */
-  argsFull: z17.string().optional(),
+  argsFull: z19.string().optional(),
   /** Short full response, or a bounded beginning/end summary for a long response. */
-  resultText: z17.string().optional(),
+  resultText: z19.string().optional(),
   /** True when `resultText` is a bounded summary rather than the complete response. */
-  resultTruncated: z17.boolean().optional(),
+  resultTruncated: z19.boolean().optional(),
   /** Image artifacts the tool returned (e.g. browser_snapshot screenshots). */
-  images: z17.array(ToolCallImageSchema).optional(),
+  images: z19.array(ToolCallImageSchema).optional(),
   /** Audio artifacts the tool returned (e.g. synthesize_speech WAV). */
-  audios: z17.array(ToolCallAudioSchema).optional(),
+  audios: z19.array(ToolCallAudioSchema).optional(),
   /** Video artifacts the tool returned (e.g. generate_video mp4). */
-  videos: z17.array(ToolCallVideoSchema).optional(),
+  videos: z19.array(ToolCallVideoSchema).optional(),
   /**
    * Unified diff describing the change a surgical-edit tool made
    * (`replace_in_file`, `apply_patch`, `insert_at_marker`). Used by the UI
    * to render an inline diff under the tool-call row. Capped at ~100KB
    * server-side; larger diffs are truncated with a marker line.
    */
-  diff: z17.string().optional(),
-  addedLines: z17.number().int().nonnegative().optional(),
-  removedLines: z17.number().int().nonnegative().optional()
-});
-var ChatMessageSchema = z17.object({
-  role: z17.enum(["user", "assistant"]),
-  content: z17.string(),
-  at: z17.string(),
-  from: z17.object({
-    gezelId: z17.string(),
-    gezelName: z17.string()
+  diff: z19.string().optional(),
+  addedLines: z19.number().int().nonnegative().optional(),
+  removedLines: z19.number().int().nonnegative().optional(),
+  /** Rich inline card payload for tools with special renderings — see ToolCallCardSchema. */
+  card: ToolCallCardSchema.optional(),
+  /**
+   * Offset into the turn's `ChatMessage.reasoning` string marking where
+   * this call fired — the same trick `intents[].afterChars` plays on
+   * `content`. Lets the collapsed Thinking expander splice a small
+   * marker into the trace at the spot the model stopped deliberating
+   * and acted, so an expanded trace reads in causal order instead of as
+   * one undifferentiated block above an unrelated tool list.
+   *
+   * Sourced from the PROVIDER's running reasoning length
+   * (`LLMSession.getCurrentTurnReasoningLength`), never from a
+   * manager-side count of `reasoning_delta` events: the persisted trace
+   * is whatever `getLastTurnReasoning()` returns, which several local
+   * providers build by extracting `<think>` blocks per tool-loop
+   * iteration rather than from the delta stream. An offset into a
+   * different string would drift silently.
+   *
+   * Absent for providers that don't implement the getter, and on every
+   * message written before this field existed — the expander then
+   * renders the plain trace it always did.
+   */
+  afterReasoningChars: z19.number().int().min(0).optional()
+});
+var ChatSessionSourceSchema = z19.object({
+  kind: z19.literal("external"),
+  /** Stable integration id, e.g. `pi`. */
+  appId: z19.string().min(1),
+  /** Human-facing application name, e.g. `Pi`. */
+  appName: z19.string().min(1),
+  /** The external application's stable conversation/session identifier. */
+  externalConversationId: z19.string().min(1),
+  /** External threads are ledger views; the owning app controls replies. */
+  readOnly: z19.literal(true),
+  /** Working-directory hint supplied by the external app, when available. */
+  workingDirectory: z19.string().optional(),
+  /** Project id/name hint supplied by the external app, when available. */
+  projectHint: z19.string().optional()
+});
+var ReferencedFileKindSchema = z19.enum(["artifact", "workspace"]);
+var ReferencedFileSchema = z19.object({
+  kind: ReferencedFileKindSchema,
+  path: z19.string()
+});
+var ChatMessageSchema = z19.object({
+  role: z19.enum(["user", "assistant"]),
+  content: z19.string(),
+  at: z19.string(),
+  from: z19.object({
+    gezelId: z19.string(),
+    gezelName: z19.string()
   }).optional(),
   /**
-   * Artifact paths (relative to the project's `artifacts/` directory)
-   * the assistant reply referenced in its body text. Populated on save
-   * by the server-side reference parser, and used by the chat UI to
-   * render a chip row under the bubble and to linkify inline code spans
-   * that match a real artifact. Back-stops Copilot's tool-call
-   * blindspot and any "AI wrote a file outside the MCP tools" paths.
+   * Real files the assistant reply named in its body text — artifacts
+   * drawer and workspace tree alike. Populated on save by the
+   * server-side reference parser, and used by the chat UI to render a
+   * chip row under the bubble and to linkify inline code spans that
+   * match a real file. Back-stops Copilot's tool-call blindspot and any
+   * "AI wrote a file outside the MCP tools" path.
+   */
+  referencedFiles: z19.array(ReferencedFileSchema).optional(),
+  /**
+   * The artifact-only projection of {@link referencedFiles}, still
+   * written so an older `@bendyline/gezel-cli` (or any out-of-tree
+   * reader) keeps working against a session file this daemon wrote.
+   * Read `referencedFiles` in new code — this field cannot represent a
+   * workspace path.
+   *
+   * @deprecated superseded by `referencedFiles`
    */
-  referencedArtifacts: z17.array(z17.string()).optional(),
+  referencedArtifacts: z19.array(z19.string()).optional(),
   /**
    * Task refs (`<projectId>/<num>`) the assistant reply mentioned. Same
-   * shape as `referencedArtifacts` — populated on save, gated on the
+   * shape as `referencedFiles` — populated on save, gated on the
    * ref actually existing in the task store, surfaced in the chat
    * bubble as click-through chips. Catches the common "I created task
    * gezel-ux-roadmap/2" mention so the user can jump to it without
    * scrolling the body for the ref.
    */
-  referencedTasks: z17.array(z17.string()).optional(),
+  referencedTasks: z19.array(z19.string()).optional(),
+  /**
+   * Indexed-context sources consulted for THIS user turn (proactive
+   * retrieval). Citations only — source/path/line/score, never the retrieved
+   * text (which lives solely in the provider prompt). Lets the UI render a
+   * "consulted N sources" row so proactive RAG is visible diligence instead
+   * of invisible machinery.
+   */
+  retrieval: z19.object({
+    hits: z19.array(
+      z19.object({
+        source: RetrievalSourceSchema,
+        projectId: z19.string().optional(),
+        path: z19.string().optional(),
+        line: z19.number().int().positive().optional(),
+        lineEnd: z19.number().int().positive().optional(),
+        score: z19.number()
+      })
+    )
+  }).optional(),
   /**
    * Tool calls the assistant fired during this turn. Populated on the
    * final assistant message; the UI renders them as a collapsible
    * "thinking" expando above the reply body so the user can still see
    * what ran even after the live stream has closed.
    */
-  toolCalls: z17.array(ChatMessageToolCallSchema).optional(),
+  toolCalls: z19.array(ChatMessageToolCallSchema).optional(),
   /**
    * Phase announcements the model emitted via Copilot's `report_intent`
    * tool during this turn. Each entry carries the intent label and an
@@ -3052,10 +3416,10 @@ var ChatMessageSchema = z17.object({
    * replay and history export are unaffected. Copilot-only; other
    * providers don't emit these.
    */
-  intents: z17.array(
-    z17.object({
-      label: z17.string(),
-      afterChars: z17.number().int().min(0)
+  intents: z19.array(
+    z19.object({
+      label: z19.string(),
+      afterChars: z19.number().int().min(0)
     })
   ).optional(),
   /**
@@ -3065,7 +3429,7 @@ var ChatMessageSchema = z17.object({
    * itself lives in the per-project questions file; this id is just
    * the foreign key.
    */
-  pendingQuestionId: z17.string().optional(),
+  pendingQuestionId: z19.string().optional(),
   /**
    * Marks the message as a system-generated synthesis rather than a real
    * model turn.
@@ -3094,7 +3458,7 @@ var ChatMessageSchema = z17.object({
    * UI renders these as muted bubbles; the model sees them as normal
    * assistant turns (the role label is what matters to the API).
    */
-  synthetic: z17.enum([
+  synthetic: z19.enum([
     "compaction-summary",
     "context-loop-halt",
     "turn-aborted",
@@ -3112,7 +3476,7 @@ var ChatMessageSchema = z17.object({
    * from loaded transcripts and the live-timeline handler skips its bubble
    * while still opening the assistant's streaming slot.
    */
-  hidden: z17.boolean().optional(),
+  hidden: z19.boolean().optional(),
   /**
    * This user message was delivered from the session's mid-turn queue
    * as a nudge — typed while the previous turn was still streaming and
@@ -3120,7 +3484,26 @@ var ChatMessageSchema = z17.object({
    * Display-only marker: the model sees a normal user turn; the UI
    * renders a small "nudged" chip on the bubble.
    */
-  nudge: z17.boolean().optional(),
+  nudge: z19.boolean().optional(),
+  /**
+   * The machinery — not the human — authored this `role: 'user'` message.
+   * Task dispatch seeds, step handoffs, and project-page reaction seeds
+   * all arrive as user turns because that is the only role a provider
+   * will accept mid-conversation, but the person never typed them.
+   *
+   * Display-only marker: the model still sees an ordinary user turn, and
+   * the UI labels the bubble **System** instead of "You". Without it the
+   * flagship Home thread opened with "YOU · call `advance_task_step` to
+   * hand off" — internal plumbing quoted back at the user in their own
+   * voice, which reads as a bug and undoes the warm-companion framing the
+   * whole product rests on.
+   *
+   * Set from the turn's `messageOrigin` (service-side `TurnMessageOrigin`);
+   * an enum rather than a boolean so a future dispatch/reaction split can
+   * widen it without a second field. Messages written before this field
+   * existed are inferred at read time — see `Store.listTimeline`.
+   */
+  origin: z19.enum(["system"]).optional(),
   /**
    * Persistent warnings attached to this assistant turn — fabricated
    * tool-use detection, degraded provider state, etc. The streaming
@@ -3130,7 +3513,7 @@ var ChatMessageSchema = z17.object({
    * reload. Populated by the chat manager just before `events.publish`
    * fires the `complete` event.
    */
-  warnings: z17.array(z17.string()).optional(),
+  warnings: z19.array(z19.string()).optional(),
   /**
    * Chain-of-thought captured during this turn. Local providers
    * (ollama, llama-cpp, mlx, ds4) extract `<think>…</think>` /
@@ -3143,14 +3526,14 @@ var ChatMessageSchema = z17.object({
    * Responses hides reasoning server-side and leaves this unset.
    * Empty / whitespace-only captures are dropped.
    */
-  reasoning: z17.string().optional(),
+  reasoning: z19.string().optional(),
   /**
    * Observed wall-clock span of the streamed private-reasoning trace,
    * measured from the first `reasoning_delta` to the last. Optional
    * because older messages and providers that only expose reasoning at
    * commit time have no trustworthy phase timing.
    */
-  reasoningDurationMs: z17.number().int().nonnegative().optional(),
+  reasoningDurationMs: z19.number().int().nonnegative().optional(),
   /**
    * Tool-call bodies the model emitted that the salvage layer
    * couldn't parse — the literal text from `<|tool_call|>` markers
@@ -3165,10 +3548,10 @@ var ChatMessageSchema = z17.object({
    * hundred chars per body in the populator so a long fabricated body
    * doesn't blow up the session file.
    */
-  attemptedToolCalls: z17.array(
-    z17.object({
-      body: z17.string(),
-      reason: z17.string().optional()
+  attemptedToolCalls: z19.array(
+    z19.object({
+      body: z19.string(),
+      reason: z19.string().optional()
     })
   ).optional(),
   /**
@@ -3184,28 +3567,28 @@ var ChatMessageSchema = z17.object({
    * daemon restart, a provider reset, or a context-pressure rebuild — leaving
    * the model replaying a bare `![](attachments/9f3.png)`.
    */
-  recognizedImages: z17.array(MessageImageDigestSchema).optional()
+  recognizedImages: z19.array(MessageImageDigestSchema).optional()
 });
-var ChatTurnErrorDetailSchema = z17.object({
-  code: z17.string().max(64).optional(),
+var ChatTurnErrorDetailSchema = z19.object({
+  code: z19.string().max(64).optional(),
   /** Component that failed — a provider name (`llama-cpp`) or a subsystem. */
-  engine: z17.string().max(64).optional(),
+  engine: z19.string().max(64).optional(),
   /** Correlation key, also written into the engine's own incident log. */
-  incidentId: z17.string().max(64).optional(),
+  incidentId: z19.string().max(64).optional(),
   /** Native crash class from the exit snapshot, e.g. `cuda-out-of-memory`. */
-  panicKind: z17.string().max(64).optional(),
-  exitCode: z17.number().int().nullable().optional(),
-  signal: z17.string().max(32).nullable().optional(),
+  panicKind: z19.string().max(64).optional(),
+  exitCode: z19.number().int().nullable().optional(),
+  signal: z19.string().max(32).nullable().optional(),
   /**
    * Request-independent launch facts copied from the crash snapshot, which
    * is contractually free of prompts, tool arguments, and secrets. Bounded
    * by the extractor. A machine profile cannot reconstruct which model at
    * which context size with which KV type crashed; this can.
    */
-  diagnostics: z17.record(z17.string(), z17.union([z17.string(), z17.number(), z17.boolean()])).optional()
+  diagnostics: z19.record(z19.string(), z19.union([z19.string(), z19.number(), z19.boolean()])).optional()
 });
-var ChatEventSchema = z17.discriminatedUnion("type", [
-  z17.object({ type: z17.literal("delta"), content: z17.string() }),
+var ChatEventSchema = z19.discriminatedUnion("type", [
+  z19.object({ type: z19.literal("delta"), content: z19.string() }),
   /**
    * Live private-reasoning tokens (ds4's think phase), streamed on their
    * own channel so they never mix into the visible `delta` stream, the
@@ -3213,14 +3596,14 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * renders them as a distinct "thinking" block that collapses into the
    * committed message's reasoning expander once `complete` lands.
    */
-  z17.object({ type: z17.literal("reasoning_delta"), content: z17.string() }),
-  z17.object({ type: z17.literal("complete"), message: ChatMessageSchema }),
+  z19.object({ type: z19.literal("reasoning_delta"), content: z19.string() }),
+  z19.object({ type: z19.literal("complete"), message: ChatMessageSchema }),
   /**
    * The user submitted a message, but a cold provider session is still being
    * created. Project timelines render this as a temporary pending row until
    * the durable `user_message` or a terminal `error` arrives.
    */
-  z17.object({ type: z17.literal("user_message_pending"), preview: z17.string() }),
+  z19.object({ type: z19.literal("user_message_pending"), preview: z19.string() }),
   /**
    * Emitted right after the user's message is appended to the session
    * record. The legacy session-scoped UI inserted user messages locally
@@ -3228,27 +3611,27 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * envelope streams need it so the interleaved timeline can render the
    * user's bubble immediately, before any assistant deltas.
    */
-  z17.object({ type: z17.literal("user_message"), message: ChatMessageSchema }),
+  z19.object({ type: z19.literal("user_message"), message: ChatMessageSchema }),
   /**
    * Emitted when the assistant invokes an MCP tool (OpenAI + Mock paths
    * only — Copilot runs tools inside its subprocess, invisible to us).
    * The UI surfaces these as "thinking" breadcrumbs.
    */
-  z17.object({
-    type: z17.literal("tool"),
-    name: z17.string(),
-    durationMs: z17.number(),
-    success: z17.boolean(),
-    errorMessage: z17.string().optional(),
+  z19.object({
+    type: z19.literal("tool"),
+    name: z19.string(),
+    durationMs: z19.number(),
+    success: z19.boolean(),
+    errorMessage: z19.string().optional(),
     /**
      * File path the tool touched (if any). Set for tools that take a `path`
      * argument: readFile, writeFile, read_artifact, write_artifact,
      * read_document, write_document. Lets the UI build a References panel
      * without guessing.
      */
-    path: z17.string().optional(),
+    path: z19.string().optional(),
     /** Ordered file paths touched by a batched filesystem tool. */
-    paths: z17.array(z17.string()).optional(),
+    paths: z19.array(z19.string()).optional(),
     /**
      * Compact human-readable preview of the non-bulky arguments. Example:
      * `gezel: "Maya", message: "what's the status of..."`. Values are
@@ -3256,44 +3639,46 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
      * UI to render a useful in-progress tool line instead of just the
      * tool name.
      */
-    argsSummary: z17.string().optional(),
+    argsSummary: z19.string().optional(),
     /** Full, readable args for the expand + copy affordance. See the persisted `ChatMessageToolCall.argsFull`. */
-    argsFull: z17.string().optional(),
+    argsFull: z19.string().optional(),
     /** Short full response, or a bounded beginning/end summary. */
-    resultText: z17.string().optional(),
+    resultText: z19.string().optional(),
     /** True when `resultText` is a bounded summary rather than the complete response. */
-    resultTruncated: z17.boolean().optional(),
+    resultTruncated: z19.boolean().optional(),
     /**
      * Image artifacts the tool returned (most commonly browser screenshots).
      * Paths are relative to the project's artifacts/ root and resolved
      * to URLs by the UI via the artifact-read endpoint.
      */
-    images: z17.array(ToolCallImageSchema).optional(),
+    images: z19.array(ToolCallImageSchema).optional(),
     /**
      * Audio artifacts the tool returned (synthesize_speech narrations,
      * voice memos transcribed via transcribe_audio). Same artifact-path
      * resolution as `images`.
      */
-    audios: z17.array(ToolCallAudioSchema).optional(),
+    audios: z19.array(ToolCallAudioSchema).optional(),
     /**
      * Video artifacts the tool returned (`generate_video`). Same
      * artifact-path resolution as `images`; rendered as a `<video>`
      * player in the chat row.
      */
-    videos: z17.array(ToolCallVideoSchema).optional(),
+    videos: z19.array(ToolCallVideoSchema).optional(),
     /**
      * Unified diff describing the change a surgical-edit tool made
      * (`replace_in_file`, `apply_patch`, `insert_at_marker`). Streams to the
      * UI mid-turn so the chat bubble can render an inline diff under
      * the tool-call row even before the assistant message is finalized.
      */
-    diff: z17.string().optional(),
-    addedLines: z17.number().int().nonnegative().optional(),
-    removedLines: z17.number().int().nonnegative().optional()
+    diff: z19.string().optional(),
+    addedLines: z19.number().int().nonnegative().optional(),
+    removedLines: z19.number().int().nonnegative().optional(),
+    /** Rich inline card payload for tools with special renderings — see ToolCallCardSchema. */
+    card: ToolCallCardSchema.optional()
   }),
-  z17.object({
-    type: z17.literal("error"),
-    error: z17.string(),
+  z19.object({
+    type: z19.literal("error"),
+    error: z19.string(),
     // Not `detail` — three sibling variants in this union already use that
     // name for free-form progress prose, and one union with two meanings for
     // one key is a trap.
@@ -3304,8 +3689,8 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * surface. This is terminal for the live UI, but is deliberately not an
    * error: it must not poison the session or render failure recovery UI.
    */
-  z17.object({ type: z17.literal("cancelled") }),
-  z17.object({ type: z17.literal("done") }),
+  z19.object({ type: z19.literal("cancelled") }),
+  z19.object({ type: z19.literal("done") }),
   /**
    * Emitted when a turn ends up waiting in the provider queue for more
    * than a brief grace period (~200ms). `aheadOf` is an approximate
@@ -3315,7 +3700,7 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * emit this event — avoids flashing the indicator on the happy path
    * where the queue is empty.
    */
-  z17.object({ type: z17.literal("queued"), aheadOf: z17.number().int().min(0) }),
+  z19.object({ type: z19.literal("queued"), aheadOf: z19.number().int().min(0) }),
   /**
    * Ollama-only: emitted for each bare framing chunk that arrives
    * on the wire without visible content / tool_calls — the
@@ -3325,7 +3710,7 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * when the model isn't producing visible output. Reset on the
    * next real `delta`, `tool`, or `complete`.
    */
-  z17.object({ type: z17.literal("wire_pulse") }),
+  z19.object({ type: z19.literal("wire_pulse") }),
   /**
    * Live tool-argument stream. Fired while the model is generating a
    * structured tool call — most visibly a multi-minute `write_file`
@@ -3337,7 +3722,7 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * "working" block (same pattern as `reasoning_delta`) and drops the
    * block when the corresponding `tool` event lands.
    */
-  z17.object({ type: z17.literal("tool_args_delta"), name: z17.string(), content: z17.string() }),
+  z19.object({ type: z19.literal("tool_args_delta"), name: z19.string(), content: z19.string() }),
   /**
    * Emitted when a provider tells us it's still doing work — even though
    * no visible text/tool event has arrived. Today this is wired from
@@ -3348,24 +3733,24 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * Optional `label` carries a short phase hint ('thinking', 'tool',
    * etc.) that the streaming bubble can surface as a status line.
    */
-  z17.object({ type: z17.literal("heartbeat"), label: z17.string().optional() }),
+  z19.object({ type: z19.literal("heartbeat"), label: z19.string().optional() }),
   /**
    * Provider-side warning surfaced mid-turn (e.g. Copilot rate-limit,
    * context pressure, degraded mode). The UI renders these inline on
    * the streaming bubble so the user sees them immediately instead of
    * only finding out when the turn completes or times out.
    */
-  z17.object({
-    type: z17.literal("warning"),
-    message: z17.string(),
+  z19.object({
+    type: z19.literal("warning"),
+    message: z19.string(),
     /**
      * Optional in-app destination for a warning's inline action. Kept
      * deliberately narrow: warnings are still readable prose when an older
      * client ignores this additive field.
      */
-    action: z17.object({
-      kind: z17.literal("settings"),
-      section: z17.enum(["llamaCpp", "mlx", "ds4"])
+    action: z19.object({
+      kind: z19.literal("settings"),
+      section: z19.enum(["llamaCpp", "mlx", "ds4"])
     }).optional()
   }),
   /**
@@ -3376,18 +3761,18 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * offset on the final assistant message so completed bubbles render
    * the same segmentation on reload.
    */
-  z17.object({ type: z17.literal("intent"), label: z17.string() }),
+  z19.object({ type: z19.literal("intent"), label: z19.string() }),
   /**
    * Emitted when a new message is enqueued on the per-session queue
    * because the session already has a turn in flight. The timeline
    * renders a "ghost bubble" under the session's streaming bubble
    * showing the queued text preview. Cleared via `queue_removed`.
    */
-  z17.object({
-    type: z17.literal("queue_enqueued"),
-    queueId: z17.string(),
-    preview: z17.string(),
-    enqueuedAt: z17.string(),
+  z19.object({
+    type: z19.literal("queue_enqueued"),
+    queueId: z19.string(),
+    preview: z19.string(),
+    enqueuedAt: z19.string(),
     /**
      * The entry was queued as a mid-turn nudge — the ghost bubble labels
      * it "nudge" and contiguous nudges merge into one turn on drain.
@@ -3395,7 +3780,7 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
      * every coalesce/edit); the edit affordance fetches it lazily via
      * `GET /api/sessions/:id/queue`.
      */
-    nudge: z17.boolean().optional()
+    nudge: z19.boolean().optional()
   }),
   /**
    * Emitted when a queued entry leaves the queue — either because
@@ -3404,10 +3789,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * dropped without running (`reason: 'canceled'` via user action,
    * `reason: 'rejected'` via session archive / delete / shutdown).
    */
-  z17.object({
-    type: z17.literal("queue_removed"),
-    queueId: z17.string(),
-    reason: z17.enum(["started", "canceled", "rejected"])
+  z19.object({
+    type: z19.literal("queue_removed"),
+    queueId: z19.string(),
+    reason: z19.enum(["started", "canceled", "rejected"])
   }),
   /**
    * Local-provider context policy: emitted when accumulated conversation
@@ -3415,11 +3800,11 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * The UI may suggest starting fresh because this event is never emitted
    * for a first-turn standing system/tool prefix.
    */
-  z17.object({
-    type: z17.literal("context_warning"),
-    estimatedTokens: z17.number(),
-    numCtx: z17.number(),
-    model: z17.string()
+  z19.object({
+    type: z19.literal("context_warning"),
+    estimatedTokens: z19.number(),
+    numCtx: z19.number(),
+    model: z19.string()
   }),
   /**
    * Local-provider context policy: emitted right after in-flight compaction collapses
@@ -3428,10 +3813,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * for a "compacted" variant and refreshes the visible timeline (older
    * bubbles are now gone from disk).
    */
-  z17.object({
-    type: z17.literal("context_compacted"),
-    removedCount: z17.number().int().nonnegative(),
-    model: z17.string()
+  z19.object({
+    type: z19.literal("context_compacted"),
+    removedCount: z19.number().int().nonnegative(),
+    model: z19.string()
   }),
   /**
    * Emitted when the chat manager detects a self-chat / compaction loop —
@@ -3440,10 +3825,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * compaction cycle without making progress. The pipeline halts the turn
    * so the user can intervene; the UI surfaces a "looks stuck" banner.
    */
-  z17.object({
-    type: z17.literal("context_loop"),
-    compactionsThisSend: z17.number().int().positive(),
-    reason: z17.string()
+  z19.object({
+    type: z19.literal("context_loop"),
+    compactionsThisSend: z19.number().int().positive(),
+    reason: z19.string()
   }),
   /**
    * Emitted when the Keurmeester (frontier quality inspector) steps in
@@ -3451,23 +3836,23 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * UI renders a "stepped in" notice on the thread; the full case
    * record lives under `~/.gezel/keurmeester/cases/` keyed by caseId.
    */
-  z17.object({
-    type: z17.literal("keurmeester_intervention"),
-    caseId: z17.string(),
-    gezelId: z17.string(),
-    gezelName: z17.string(),
-    action: z17.string(),
-    summary: z17.string()
+  z19.object({
+    type: z19.literal("keurmeester_intervention"),
+    caseId: z19.string(),
+    gezelId: z19.string(),
+    gezelName: z19.string(),
+    action: z19.string(),
+    summary: z19.string()
   }),
   /**
    * Emitted once per session the first time auto-recall runs, so the UI
    * can render a "pulled N memories from prior work" chip above the first
    * assistant reply.
    */
-  z17.object({
-    type: z17.literal("recall_applied"),
-    hitCount: z17.number(),
-    query: z17.string()
+  z19.object({
+    type: z19.literal("recall_applied"),
+    hitCount: z19.number(),
+    query: z19.string()
   }),
   /**
    * Emitted when a gezel posts a structured question via the
@@ -3475,14 +3860,14 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * questions on this event so the in-chat card, Home pane, and Home
    * tab badge all light up together.
    */
-  z17.object({ type: z17.literal("question_asked"), question: QuestionSchema }),
+  z19.object({ type: z19.literal("question_asked"), question: QuestionSchema }),
   /**
    * Emitted when the user submits (or declines) an answer. The UI
    * uses the same fan-out as `question_asked` to refresh every
    * surface; the chat bubble's pending card collapses to its
    * answered state.
    */
-  z17.object({ type: z17.literal("question_answered"), question: QuestionSchema }),
+  z19.object({ type: z19.literal("question_answered"), question: QuestionSchema }),
   /**
    * A durable task audit event, fanned onto the project's live stream after
    * it has been appended to History. This keeps lightweight clients (most
@@ -3490,13 +3875,13 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * second task lifecycle bus. `task.tick` heartbeats are intentionally not
    * published; this channel is for user-meaningful changes.
    */
-  z17.object({
-    type: z17.literal("task_event"),
-    eventId: z17.string(),
-    kind: z17.string(),
-    summary: z17.string(),
-    at: z17.string(),
-    taskRef: z17.string().optional(),
+  z19.object({
+    type: z19.literal("task_event"),
+    eventId: z19.string(),
+    kind: z19.string(),
+    summary: z19.string(),
+    at: z19.string(),
+    taskRef: z19.string().optional(),
     /**
      * Gezel responsible for the event, when History recorded one. Kept
      * separate from the human-readable summary so fixed-presentation
@@ -3504,18 +3889,18 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
      * their own naming mode instead of leaking the friendly name embedded
      * in the audit prose.
      */
-    gezelId: z17.string().optional()
+    gezelId: z19.string().optional()
   }),
   /**
    * Emitted when a gezel crosses a growth level threshold and a pending
    * level-up is created. The UI refreshes growth badges/dots and raises
    * a single calm OS notification when the window is hidden.
    */
-  z17.object({
-    type: z17.literal("growth_level_up"),
-    gezelId: z17.string(),
-    gezelName: z17.string(),
-    toLevel: z17.number().int()
+  z19.object({
+    type: z19.literal("growth_level_up"),
+    gezelId: z19.string(),
+    gezelName: z19.string(),
+    toLevel: z19.number().int()
   }),
   /**
    * llama-cpp-only: lifecycle phase of the supervised on-device engine
@@ -3538,17 +3923,39 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * the phase label so users who want to know what's happening can
    * see, without cluttering the happy-path status line.
    */
-  z17.object({
-    type: z17.literal("engine_phase"),
-    provider: z17.enum(["llama-cpp", "mlx", "ds4"]),
-    phase: z17.enum(["starting", "loading_model", "prefill", "generating", "ready"]),
-    detail: z17.string().optional(),
-    progress: z17.number().min(0).max(1).optional(),
-    ttftMs: z17.number().int().nonnegative().optional()
+  z19.object({
+    type: z19.literal("engine_phase"),
+    provider: z19.enum(["llama-cpp", "mlx", "ds4"]),
+    phase: z19.enum(["starting", "loading_model", "prefill", "generating", "ready"]),
+    /**
+     * Human-readable subject for an ephemeral background completion. Unlike
+     * `detail` (engine diagnostics), this names the user's work — for example
+     * "Indexing src/app.ts". Ordinary chat turns leave it absent.
+     */
+    activity: z19.string().optional(),
+    detail: z19.string().optional(),
+    progress: z19.number().min(0).max(1).optional(),
+    ttftMs: z19.number().int().nonnegative().optional(),
+    /**
+     * Exact cumulative completion tokens decoded so far this turn, as the
+     * engine counts them (llama-server `timings.predicted_n`, MLX's
+     * streamed `usage.output_tokens`). Present only on `generating`, and
+     * only for engines that publish a running counter — the UI falls back
+     * to an explicitly-approximate character estimate when it is absent,
+     * so this field is what lets a readout drop its "≈".
+     */
+    outputTokens: z19.number().int().nonnegative().optional(),
+    /**
+     * Exact decode rate right now, engine-measured over the generation
+     * phase alone (llama-server `timings.predicted_per_second`, MLX's
+     * `generation_tps`). Same contract as `outputTokens`: absent means the
+     * UI must derive and mark its own estimate.
+     */
+    tokensPerSec: z19.number().nonnegative().optional()
   }),
   /**
-   * Per-turn telemetry for locally-hosted providers (llama-cpp +
-   * Ollama). Emitted once at turn end with the concrete token counts
+   * Per-turn telemetry for locally-hosted providers (llama-cpp, Ollama,
+   * MLX, and DS4). Emitted once at turn end with the concrete token counts
    * the UI needs for a speed readout — input tokens, output tokens,
    * wall-clock duration, and tokens-per-second on the generation
    * phase. UI accumulates these in a rolling window to show an
@@ -3559,14 +3966,21 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * local speed metric isn't meaningful when the latency is
    * dominated by network round-trips.
    */
-  z17.object({
-    type: z17.literal("turn_stats"),
-    provider: z17.enum(["llama-cpp", "ollama", "mlx", "ds4"]),
-    promptTokens: z17.number().int().nonnegative(),
-    completionTokens: z17.number().int().nonnegative(),
-    durationMs: z17.number().int().nonnegative(),
+  z19.object({
+    type: z19.literal("turn_stats"),
+    provider: z19.enum(["llama-cpp", "ollama", "mlx", "ds4"]),
+    /**
+     * Model that generated the turn, as the session recorded it. Lets the
+     * UI bucket speed by model instead of averaging a 27B and a 4B into
+     * one meaningless number. Optional because older daemons (and remote
+     * peers on an older wire) don't send it.
+     */
+    model: z19.string().optional(),
+    promptTokens: z19.number().int().nonnegative(),
+    completionTokens: z19.number().int().nonnegative(),
+    durationMs: z19.number().int().nonnegative(),
     /** Generation speed in tokens/sec — completionTokens / generationSeconds. */
-    tokensPerSec: z17.number().nonnegative().optional()
+    tokensPerSec: z19.number().nonnegative().optional()
   }),
   /**
    * Static engine-level metrics that don't change during a session —
@@ -3578,11 +3992,11 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * `engine_phase` (every session waiting on the same supervisor
    * startup gets a copy).
    */
-  z17.object({
-    type: z17.literal("engine_stats"),
-    provider: z17.enum(["llama-cpp", "mlx", "ds4"]),
+  z19.object({
+    type: z19.literal("engine_stats"),
+    provider: z19.enum(["llama-cpp", "mlx", "ds4"]),
     /** Total bytes allocated across all GGUF buffers + KV cache. */
-    ramAllocBytes: z17.number().nonnegative()
+    ramAllocBytes: z19.number().nonnegative()
   }),
   /**
    * VRAM tenancy change — a non-LLM workload has taken (or released)
@@ -3612,9 +4026,9 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * `step`/`totalSteps` drive a real progress bar; `secondsPerStep`
    * lets the UI show an ETA.
    */
-  z17.object({
-    type: z17.literal("gpu_swap"),
-    state: z17.enum(["started", "progress", "ended"]),
+  z19.object({
+    type: z19.literal("gpu_swap"),
+    state: z19.enum(["started", "progress", "ended"]),
     /**
      * Shared with session telemetry so a new workload can't light up the
      * bubble while staying invisible to stall detection.
@@ -3627,12 +4041,12 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
      * seconds", which reads as a bug.
      */
     task: SessionGpuTaskSchema,
-    detail: z17.string().optional(),
-    prompt: z17.string().optional(),
-    progress: z17.number().min(0).max(1).optional(),
-    step: z17.number().int().nonnegative().optional(),
-    totalSteps: z17.number().int().positive().optional(),
-    secondsPerStep: z17.number().nonnegative().optional()
+    detail: z19.string().optional(),
+    prompt: z19.string().optional(),
+    progress: z19.number().min(0).max(1).optional(),
+    step: z19.number().int().nonnegative().optional(),
+    totalSteps: z19.number().int().positive().optional(),
+    secondsPerStep: z19.number().nonnegative().optional()
   }),
   /**
    * The turn is parked inside a synchronous `ask_gezel` /
@@ -3655,10 +4069,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * side, same as the `ask_gezel` tool result), so the UI can render
    * it verbatim.
    */
-  z17.object({
-    type: z17.literal("awaiting_gezel"),
-    state: z17.enum(["started", "ended"]),
-    targetGezelName: z17.string()
+  z19.object({
+    type: z19.literal("awaiting_gezel"),
+    state: z19.enum(["started", "ended"]),
+    targetGezelName: z19.string()
   }),
   /**
    * A new project was created (via the New Project dialog, the
@@ -3669,10 +4083,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * for the next manual refresh / tab-focus poll. Not a renderable
    * timeline event (like `growth_level_up`); the chat surfaces ignore it.
    */
-  z17.object({
-    type: z17.literal("project_created"),
-    projectId: z17.string(),
-    name: z17.string()
+  z19.object({
+    type: z19.literal("project_created"),
+    projectId: z19.string(),
+    name: z19.string()
   }),
   /**
    * A project was deleted (via the Project Actions menu, or an equivalent
@@ -3682,10 +4096,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * waiting for the next manual refresh / tab-focus poll. Not a renderable
    * timeline event; the chat surfaces ignore it.
    */
-  z17.object({
-    type: z17.literal("project_deleted"),
-    projectId: z17.string(),
-    name: z17.string()
+  z19.object({
+    type: z19.literal("project_deleted"),
+    projectId: z19.string(),
+    name: z19.string()
   }),
   /**
    * A new shared gezel joined the global roster. Emitted on the global
@@ -3694,10 +4108,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * gezels deliberately do not emit this event because they do not belong in
    * the global Gezellen list.
    */
-  z17.object({
-    type: z17.literal("gezel_created"),
-    gezelId: z17.string(),
-    name: z17.string()
+  z19.object({
+    type: z19.literal("gezel_created"),
+    gezelId: z19.string(),
+    name: z19.string()
   }),
   /**
    * Global (project-less) signal that Night Shift mode flipped ON/OFF.
@@ -3705,10 +4119,10 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * menu pill reflects the live state. `source` is the active driver
    * (scheduled window vs. a manual shift), null when inactive.
    */
-  z17.object({
-    type: z17.literal("night_shift"),
-    active: z17.boolean(),
-    source: z17.enum(["scheduled", "manual"]).nullable()
+  z19.object({
+    type: z19.literal("night_shift"),
+    active: z19.boolean(),
+    source: z19.enum(["scheduled", "manual"]).nullable()
   }),
   /**
    * Global signal from the meester status generator. `started` fires
@@ -3717,10 +4131,23 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * produced nothing usable — the Home greeting refetches on the
    * terminal states instead of polling.
    */
-  z17.object({
-    type: z17.literal("meester_status"),
-    state: z17.enum(["started", "ended", "failed"]),
-    generatedAt: z17.string().optional()
+  z19.object({
+    type: z19.literal("meester_status"),
+    state: z19.enum(["started", "ended", "failed"]),
+    generatedAt: z19.string().optional()
+  }),
+  /**
+   * Global signal from the ambient dashboard generator. `ended` means a
+   * fresh PNG landed on disk (filename is the dated file under
+   * `~/.gezel/ambient/`); the Electron shell reacts to it by re-applying
+   * the wallpaper when the user opted in, and the Settings card
+   * refreshes its preview.
+   */
+  z19.object({
+    type: z19.literal("ambient_dashboard"),
+    state: z19.enum(["started", "ended", "failed"]),
+    generatedAt: z19.string().optional(),
+    filename: z19.string().optional()
   }),
   /**
    * Global (history-free) heartbeat from the boekwachter indexing loops —
@@ -3728,23 +4155,29 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * indicator pill; complements (doesn't replace) the polled per-project
    * index status. `pending` = files still awaiting AI enrichment when known.
    */
-  z17.object({
-    type: z17.literal("index_progress"),
-    phase: z17.enum(["scan", "shadow", "enrich", "review", "digest"]),
-    state: z17.enum(["started", "progress", "ended"]),
-    projectId: z17.string().optional(),
-    detail: z17.string().optional(),
-    pending: z17.number().int().nonnegative().optional(),
+  z19.object({
+    type: z19.literal("index_progress"),
+    phase: z19.enum(["scan", "shadow", "enrich", "review", "digest"]),
+    state: z19.enum(["started", "progress", "ended"]),
+    projectId: z19.string().optional(),
+    detail: z19.string().optional(),
+    pending: z19.number().int().nonnegative().optional(),
     /** The concrete autonomous gezel doing this work, when the project has one. */
-    gezelId: z17.string().optional(),
+    gezelId: z19.string().optional(),
     /** Snapshot of their display name so transient progress remains human-readable. */
-    gezelName: z17.string().optional()
+    gezelName: z19.string().optional()
   })
 ]);
-var ChatEventEnvelopeSchema = z17.object({
-  sessionId: z17.string(),
-  gezelId: z17.string(),
-  projectId: z17.string(),
+var ChatEventEnvelopeSchema = z19.object({
+  sessionId: z19.string(),
+  gezelId: z19.string(),
+  projectId: z19.string(),
+  /** Present when this live session was opened by another session. */
+  parentSession: SessionParentSchema.optional(),
+  /** Immediate task-step session that handed work to this live session. */
+  handoffFrom: SessionLinkSchema.optional(),
+  /** Present for externally-owned read-only threads, including live turns. */
+  sessionSource: ChatSessionSourceSchema.optional(),
   event: ChatEventSchema
 });
 
@@ -3875,8 +4308,8 @@ function promoteBareChannelNames(text) {
 }
 
 // src/schemas/report-action.ts
-import { z as z18 } from "zod";
-var ReportActionKindSchema = z18.enum(["fire-craftbook", "create-task", "apply-edits"]);
+import { z as z20 } from "zod";
+var ReportActionKindSchema = z20.enum(["fire-craftbook", "create-task", "apply-edits"]);
 var commonFields = {
   /**
    * Author-supplied stable slug — keeps lifecycle state attached across
@@ -3884,121 +4317,121 @@ var commonFields = {
    * content hash (`a-<hash>`), which is stable only while the block's
    * body is byte-identical.
    */
-  id: z18.string().regex(/^[a-z0-9][a-z0-9_-]*$/i).optional(),
+  id: z20.string().regex(/^[a-z0-9][a-z0-9_-]*$/i).optional(),
   /** Short human label for the card ("Fix the unchecked null in parser.ts"). */
-  title: z18.string().min(1),
+  title: z20.string().min(1),
   /** One-or-two-sentence rationale shown under the title. */
-  reason: z18.string().optional(),
+  reason: z20.string().optional(),
   /**
    * Target project. Defaults to the report's own project. Cross-project
    * targets are a primary case — the bundled oversight report lives in
    * `default` but recommends work in specific projects.
    */
-  projectId: z18.string().optional()
+  projectId: z20.string().optional()
 };
-var FireCraftbookActionSchema = z18.object({
-  kind: z18.literal("fire-craftbook"),
+var FireCraftbookActionSchema = z20.object({
+  kind: z20.literal("fire-craftbook"),
   ...commonFields,
-  craftbookId: z18.string().min(1),
+  craftbookId: z20.string().min(1),
   /** Invocation params for the craftbook's paramSchema (stringified values). */
-  params: z18.record(z18.string(), z18.string()).optional()
+  params: z20.record(z20.string(), z20.string()).optional()
 });
-var CreateTaskActionSchema = z18.object({
-  kind: z18.literal("create-task"),
+var CreateTaskActionSchema = z20.object({
+  kind: z20.literal("create-task"),
   ...commonFields,
   /** Full work instruction for the bespoke task's single step. */
-  prompt: z18.string().min(1),
+  prompt: z20.string().min(1),
   /** Role to recruit for the work (ensure_gezel jobTitle). Default: software developer. */
-  role: z18.string().optional()
+  role: z20.string().optional()
 });
-var ApplyEditsActionSchema = z18.object({
-  kind: z18.literal("apply-edits"),
+var ApplyEditsActionSchema = z20.object({
+  kind: z20.literal("apply-edits"),
   ...commonFields,
-  edits: z18.array(
-    z18.object({
+  edits: z20.array(
+    z20.object({
       /** Workspace-relative target file in the TARGET project. */
-      path: z18.string().min(1),
+      path: z20.string().min(1),
       /** Artifacts-relative sidecar `.diff` path in the REPORT's project. */
-      diffArtifact: z18.string().min(1)
+      diffArtifact: z20.string().min(1)
     })
   ).min(1)
 });
-var ReportActionSchema = z18.discriminatedUnion("kind", [
+var ReportActionSchema = z20.discriminatedUnion("kind", [
   FireCraftbookActionSchema,
   CreateTaskActionSchema,
   ApplyEditsActionSchema
 ]);
-var ReportActionStateSchema = z18.enum([
+var ReportActionStateSchema = z20.enum([
   "suggested",
   "fired",
   "applied",
   "failed",
   "dismissed"
 ]);
-var ReportActionRecordSchema = z18.object({
-  actionId: z18.string(),
+var ReportActionRecordSchema = z20.object({
+  actionId: z20.string(),
   /** Artifacts-relative path of the report the action came from. */
-  reportPath: z18.string(),
+  reportPath: z20.string(),
   kind: ReportActionKindSchema,
-  contentHash: z18.string(),
-  firstSeenAt: z18.string(),
+  contentHash: z20.string(),
+  firstSeenAt: z20.string(),
   state: ReportActionStateSchema,
   /** Task materialized by fire-craftbook / create-task. */
-  taskRef: z18.string().optional(),
-  firedAt: z18.string().optional(),
+  taskRef: z20.string().optional(),
+  firedAt: z20.string().optional(),
   /** Stamped when the fired task settles. */
-  settledAt: z18.string().optional(),
-  outcome: z18.enum(["complete", "canceled"]).optional(),
+  settledAt: z20.string().optional(),
+  outcome: z20.enum(["complete", "canceled"]).optional(),
   /** apply-edits per-file results. */
-  results: z18.array(
-    z18.object({
-      path: z18.string(),
-      ok: z18.boolean(),
-      error: z18.string().optional()
+  results: z20.array(
+    z20.object({
+      path: z20.string(),
+      ok: z20.boolean(),
+      error: z20.string().optional()
     })
   ).optional()
 });
-var ReportActionParseIssueSchema = z18.object({
+var ReportActionParseIssueSchema = z20.object({
   /** Zero-based index among the report's gezel-action fences. */
-  index: z18.number().int(),
-  message: z18.string(),
+  index: z20.number().int(),
+  message: z20.string(),
   /** Raw fence body, for the "unreadable action block" card. */
-  raw: z18.string()
+  raw: z20.string()
 });
-var ReportActionViewSchema = z18.object({
+var ReportActionViewSchema = z20.object({
   action: ReportActionSchema,
-  id: z18.string(),
-  contentHash: z18.string(),
+  id: z20.string(),
+  contentHash: z20.string(),
   state: ReportActionStateSchema,
-  taskRef: z18.string().optional(),
-  firedAt: z18.string().optional(),
-  settledAt: z18.string().optional(),
-  outcome: z18.enum(["complete", "canceled"]).optional(),
-  results: z18.array(z18.object({ path: z18.string(), ok: z18.boolean(), error: z18.string().optional() })).optional(),
+  taskRef: z20.string().optional(),
+  firedAt: z20.string().optional(),
+  settledAt: z20.string().optional(),
+  outcome: z20.enum(["complete", "canceled"]).optional(),
+  results: z20.array(z20.object({ path: z20.string(), ok: z20.boolean(), error: z20.string().optional() })).optional(),
   /** The stored record predates a changed block body (report regenerated). */
-  contentChanged: z18.boolean().optional()
+  contentChanged: z20.boolean().optional()
 });
-var ReportActionsResponseSchema = z18.object({
-  actions: z18.array(ReportActionViewSchema),
-  issues: z18.array(ReportActionParseIssueSchema),
+var ReportActionsResponseSchema = z20.object({
+  actions: z20.array(ReportActionViewSchema),
+  issues: z20.array(ReportActionParseIssueSchema),
   /** Records whose action vanished from the regenerated report. */
-  stale: z18.array(ReportActionRecordSchema)
+  stale: z20.array(ReportActionRecordSchema)
 });
-var FireReportActionRequestSchema = z18.object({
+var FireReportActionRequestSchema = z20.object({
   /** Artifacts-relative report path. */
-  path: z18.string().min(1),
-  actionId: z18.string().min(1),
+  path: z20.string().min(1),
+  actionId: z20.string().min(1),
   /** apply-edits: none. fire-craftbook: overrides the block's params. */
-  params: z18.record(z18.string(), z18.string()).optional()
+  params: z20.record(z20.string(), z20.string()).optional()
 });
-var FireReportActionResponseSchema = z18.object({
+var FireReportActionResponseSchema = z20.object({
   record: ReportActionRecordSchema,
   /** Set for fire-craftbook / create-task. */
-  taskRef: z18.string().optional()
+  taskRef: z20.string().optional()
 });
-var DismissReportActionRequestSchema = z18.object({
-  path: z18.string().min(1),
-  actionId: z18.string().min(1)
+var DismissReportActionRequestSchema = z20.object({
+  path: z20.string().min(1),
+  actionId: z20.string().min(1)
 });
 
 // src/markdown/report-actions.ts