@bendyline/gezel 1.0.6 → 1.1.0

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.:-]*$/,
@@ -601,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()
   }),
   /**
@@ -646,12 +660,43 @@ 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
@@ -943,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
@@ -973,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.
@@ -983,28 +1051,87 @@ 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 CraftbookStepWritableOutputMediumSchema = z6.enum([
+  "workspace",
+  "artifact",
+  "task-note"
+]);
+var CraftbookStepOutputMediumSchema = z6.enum([
+  ...CraftbookStepWritableOutputMediumSchema.options,
+  "none"
+]);
+var CraftbookStepToolPolicySchema = z6.object({
+  disallowToolsets: z6.array(z6.string().trim().min(1)).min(1).optional(),
+  disallowBuiltinToolsets: z6.array(z6.string().trim().min(1)).min(1).optional(),
+  outputMedium: CraftbookStepOutputMediumSchema.optional(),
+  /**
+   * Other intentional write surfaces used while producing the primary
+   * result (for example edit workspace source + emit an artifact report).
+   * `none` is never a secondary medium.
+   */
+  additionalOutputMedia: z6.array(CraftbookStepWritableOutputMediumSchema).min(1).optional()
+}).strict().superRefine((policy, ctx) => {
+  const additional = new Set(policy.additionalOutputMedia ?? []);
+  if (policy.outputMedium === "none" && additional.size > 0) {
+    ctx.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["additionalOutputMedia"],
+      message: "`none` cannot have secondary output media"
+    });
+  }
+  if (policy.outputMedium && policy.outputMedium !== "none" && additional.has(policy.outputMedium)) {
+    ctx.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["additionalOutputMedia"],
+      message: "the primary output medium must not be repeated as a secondary medium"
+    });
+  }
+  const media = /* @__PURE__ */ new Set([policy.outputMedium, ...additional]);
+  const denied = new Set(policy.disallowBuiltinToolsets ?? []);
+  if (media.has("workspace") && denied.has("workspace-fs-write")) {
+    ctx.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["disallowBuiltinToolsets"],
+      message: "workspace output conflicts with disallowing `workspace-fs-write`"
+    });
+  }
+  if (media.has("artifact") && denied.has("artifacts")) {
+    ctx.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["disallowBuiltinToolsets"],
+      message: "artifact output conflicts with disallowing `artifacts`"
+    });
+  }
+  if (media.has("task-note") && denied.has("tasks")) {
+    ctx.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["disallowBuiltinToolsets"],
+      message: "task-note output conflicts with disallowing `tasks`"
+    });
+  }
+});
+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
@@ -1015,7 +1142,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;
@@ -1024,26 +1151,32 @@ 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(),
+  /** Per-step subtractive tool and output-surface policy. */
+  toolPolicy: CraftbookStepToolPolicySchema.optional(),
   assignee: TaskAssigneeSchema.optional(),
   /** Setup scripts, run in order when the step activates. Single ref = legacy shape. */
   onEnter: ScriptRefListSchema.optional(),
   /**
    * Cleanup scripts — the `finally` of the step. Run in order AFTER the
-   * gate (if any) approves; never on a gate reject. Branch predicates
-   * read the LAST ref's output (legacy routing; prefer gate routing).
+   * gate (if any) approves; never on a gate reject. Every script must
+   * succeed or the step remains incomplete and the task pauses. Branch
+   * predicates read the LAST ref's output (legacy routing; prefer gate
+   * routing).
    */
   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
@@ -1051,19 +1184,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 = [];
@@ -1118,70 +1251,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 CraftbookRunModesSchema = z5.object({
-  scheduled: z5.enum(["supported", "recommended"]).optional(),
-  nightShift: z5.enum(["supported", "recommended"]).optional()
+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 = 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})`
     });
   }
@@ -1189,14 +1340,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 [];
@@ -1218,32 +1369,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
@@ -1254,19 +1405,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(),
   /**
@@ -1277,7 +1435,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
@@ -1285,7 +1450,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
@@ -1301,10 +1466,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",
@@ -1323,97 +1508,103 @@ 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(),
+  /** See {@link CraftbookStepSchema.shape.toolPolicy}. */
+  toolPolicy: CraftbookStepToolPolicySchema.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;
@@ -1422,51 +1613,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
@@ -1642,11 +1833,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"
 ];
@@ -1656,6 +1857,8 @@ var STEP_FENCE_KEYS = [
   "suggestedGezelId",
   "suggestedRole",
   "capabilityFloor",
+  "retrieval",
+  "toolPolicy",
   "assignee",
   "deliverable",
   "onEnter",
@@ -1665,7 +1868,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 = [];
@@ -1853,10 +2059,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 = {
@@ -2002,45 +2208,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",
@@ -2048,20 +2254,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}$/;
@@ -2096,169 +2302,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",
@@ -2270,24 +2476,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()
@@ -2296,16 +2502,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*])`;
@@ -2337,36 +2543,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.
@@ -2375,123 +2586,140 @@ 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",
   "gate_infrastructure",
+  "step_exit_infrastructure",
   "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,
@@ -2499,61 +2727,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
@@ -2562,153 +2790,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",
@@ -2730,27 +2976,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`, …
@@ -2758,7 +3004,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
@@ -2767,9 +3013,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.
@@ -2802,8 +3048,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
@@ -2813,14 +3059,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`
@@ -2829,7 +3081,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
@@ -2837,7 +3089,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
@@ -2845,7 +3097,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,
@@ -2854,7 +3106,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.
@@ -2880,7 +3132,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
@@ -2889,7 +3141,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.
@@ -2899,46 +3151,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`. */
@@ -2951,7 +3205,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
@@ -2961,9 +3215,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
@@ -2973,15 +3227,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 —
@@ -2989,11 +3243,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
@@ -3003,43 +3257,95 @@ 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 ToolCardStepSchema = z19.object({
+  id: z19.string(),
+  name: z19.string(),
+  status: z19.enum(["done", "active", "pending"])
 });
-var ChatMessageToolCallSchema = z17.object({
-  name: z17.string(),
-  durationMs: z17.number(),
-  success: z17.boolean(),
-  errorMessage: z17.string().optional(),
+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(),
+  /**
+   * ISO timestamp of the call's START. Optional: absent on every message
+   * persisted before this field existed, so readers must not assume it.
+   * End time derives as `at + durationMs`. This is what gives replay
+   * (run recordings, the eval movie pipeline) intra-turn ordering with
+   * absolute time — array order alone cannot place calls on a timeline.
+   */
+  at: z19.string().optional(),
+  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
@@ -3050,54 +3356,95 @@ 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()
+  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 = z17.object({
-  kind: z17.literal("external"),
+var ChatSessionSourceSchema = z19.object({
+  kind: z19.literal("external"),
   /** Stable integration id, e.g. `pi`. */
-  appId: z17.string().min(1),
+  appId: z19.string().min(1),
   /** Human-facing application name, e.g. `Pi`. */
-  appName: z17.string().min(1),
+  appName: z19.string().min(1),
   /** The external application's stable conversation/session identifier. */
-  externalConversationId: z17.string().min(1),
+  externalConversationId: z19.string().min(1),
   /** External threads are ledger views; the owning app controls replies. */
-  readOnly: z17.literal(true),
+  readOnly: z19.literal(true),
   /** Working-directory hint supplied by the external app, when available. */
-  workingDirectory: z17.string().optional(),
+  workingDirectory: z19.string().optional(),
   /** Project id/name hint supplied by the external app, when available. */
-  projectHint: z17.string().optional()
+  projectHint: z19.string().optional()
 });
-var ReferencedFileKindSchema = z17.enum(["artifact", "workspace"]);
-var ReferencedFileSchema = z17.object({
+var ReferencedFileKindSchema = z19.enum(["artifact", "workspace"]);
+var ReferencedFileSchema = z19.object({
   kind: ReferencedFileKindSchema,
-  path: z17.string()
-});
-var ChatMessageSchema = z17.object({
-  role: z17.enum(["user", "assistant"]),
-  content: z17.string(),
-  at: z17.string(),
-  from: z17.object({
-    gezelId: z17.string(),
-    gezelName: z17.string()
+  path: z19.string()
+});
+var ContextCompactionSchema = z19.object({
+  removedCount: z19.number().int().nonnegative(),
+  contextWindow: z19.number().int().positive(),
+  estimatedTokensBefore: z19.number().int().nonnegative(),
+  compactionCount: z19.number().int().positive(),
+  autoCompactRatio: z19.number().positive().max(1)
+});
+var ChatMessageSchema = z19.object({
+  role: z19.enum(["user", "assistant"]),
+  content: z19.string(),
+  at: z19.string(),
+  from: z19.object({
+    gezelId: z19.string(),
+    gezelName: z19.string(),
+    /**
+     * The SENDER's session id — the durable per-edge record of which
+     * thread this message came from. `session.parentSession` only says
+     * which session first opened the thread (stable containment);
+     * this field is the ground truth for every individual delegation
+     * edge, including later senders into an existing session. Optional:
+     * absent on messages persisted before the field existed.
+     */
+    sessionId: z19.string().optional(),
+    /** How the sender reached this session; mirrors SessionParent.kind. */
+    kind: z19.enum(["delegation", "consultation", "task-entry", "task-handoff"]).optional()
   }).optional(),
   /**
    * Real files the assistant reply named in its body text — artifacts
@@ -3107,7 +3454,7 @@ var ChatMessageSchema = z17.object({
    * match a real file. Back-stops Copilot's tool-call blindspot and any
    * "AI wrote a file outside the MCP tools" path.
    */
-  referencedFiles: z17.array(ReferencedFileSchema).optional(),
+  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
@@ -3117,7 +3464,7 @@ var ChatMessageSchema = z17.object({
    *
    * @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 `referencedFiles` — populated on save, gated on the
@@ -3126,14 +3473,33 @@ var ChatMessageSchema = z17.object({
    * 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
@@ -3144,10 +3510,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(),
   /**
@@ -3157,7 +3523,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.
@@ -3186,13 +3552,20 @@ 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",
     "growth-announcement",
     "keurmeester-notice"
   ]).optional(),
+  /**
+   * Present on a synthetic `compaction-summary` message. The UI renders this
+   * as an explicit context-maintenance marker (including the effective token
+   * window and number of messages summarized) rather than pretending it was
+   * an ordinary assistant reply.
+   */
+  contextCompaction: ContextCompactionSchema.optional(),
   /**
    * Display flag: the model sees this message as normal history, but the
    * chat transcript UI never renders a bubble for it. Set on
@@ -3204,7 +3577,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
@@ -3212,7 +3585,14 @@ 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 prompt draft (`artifacts/prompts/<draftId>/`) this user message was
+   * sent from. Display-only: the model never sees it, and the draft may since
+   * have been swept, so the UI must treat a dangling id as "no prompt to
+   * open" rather than an error.
+   */
+  draftId: z19.string().optional(),
   /**
    * The machinery — not the human — authored this `role: 'user'` message.
    * Task dispatch seeds, step handoffs, and project-page reaction seeds
@@ -3231,7 +3611,7 @@ var ChatMessageSchema = z17.object({
    * widen it without a second field. Messages written before this field
    * existed are inferred at read time — see `Store.listTimeline`.
    */
-  origin: z17.enum(["system"]).optional(),
+  origin: z19.enum(["system"]).optional(),
   /**
    * Persistent warnings attached to this assistant turn — fabricated
    * tool-use detection, degraded provider state, etc. The streaming
@@ -3241,7 +3621,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>` /
@@ -3254,14 +3634,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
@@ -3276,10 +3656,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(),
   /**
@@ -3295,28 +3675,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
@@ -3324,14 +3704,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
@@ -3339,27 +3719,29 @@ 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(),
+    /** ISO start-of-call timestamp; see ChatMessageToolCallSchema.at. */
+    at: z19.string().optional(),
+    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
@@ -3367,44 +3749,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.
@@ -3415,8 +3799,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
@@ -3426,7 +3810,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
@@ -3436,7 +3820,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`
@@ -3448,7 +3832,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
@@ -3459,24 +3843,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()
   }),
   /**
@@ -3487,18 +3871,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.
@@ -3506,7 +3890,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
@@ -3515,22 +3899,39 @@ 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"])
+  }),
+  /**
+   * Effective context policy for a local or remote-local session. Emitted on
+   * each turn so the live UI can show the model's token window immediately;
+   * the same values are persisted on the session for reloads.
+   */
+  z19.object({
+    type: z19.literal("context_window"),
+    numCtx: z19.number().int().positive(),
+    model: z19.string(),
+    autoCompactRatio: z19.number().positive().max(1),
+    /**
+     * Estimated prompt size for the turn about to run, in the same
+     * chars/4 units the compaction check itself uses. Absent on older
+     * daemons, which published the window without the fill.
+     */
+    estimatedTokens: z19.number().int().nonnegative().optional()
   }),
   /**
-   * Local-provider context policy: emitted when accumulated conversation
-   * exceeds a safety fraction of the session's effective model context.
-   * The UI may suggest starting fresh because this event is never emitted
-   * for a first-turn standing system/tool prefix.
+   * Local-provider context policy: emitted only when accumulated conversation
+   * could not be compacted automatically. Normal pressure is handled without
+   * a warning; this is the exceptional maintenance-failure path.
    */
-  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(),
+    reason: z19.literal("compaction_failed").optional()
   }),
   /**
    * Local-provider context policy: emitted right after in-flight compaction collapses
@@ -3539,10 +3940,16 @@ 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(),
+    /** Optional for wire compatibility with pre-context-visibility daemons. */
+    numCtx: z19.number().int().positive().optional(),
+    estimatedTokensBefore: z19.number().int().nonnegative().optional(),
+    autoCompactRatio: z19.number().positive().max(1).optional(),
+    compactionCount: z19.number().int().positive().optional(),
+    mode: z19.enum(["between-turn", "mid-turn"]).optional()
   }),
   /**
    * Emitted when the chat manager detects a self-chat / compaction loop —
@@ -3551,10 +3958,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
@@ -3562,23 +3969,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
@@ -3586,14 +3993,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
@@ -3601,13 +4008,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
@@ -3615,18 +4022,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
@@ -3649,13 +4056,19 @@ 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
@@ -3664,14 +4077,14 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
      * to an explicitly-approximate character estimate when it is absent,
      * so this field is what lets a readout drop its "≈".
      */
-    outputTokens: z17.number().int().nonnegative().optional(),
+    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: z17.number().nonnegative().optional()
+    tokensPerSec: z19.number().nonnegative().optional()
   }),
   /**
    * Per-turn telemetry for locally-hosted providers (llama-cpp, Ollama,
@@ -3686,21 +4099,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"]),
+  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: z17.string().optional(),
-    promptTokens: z17.number().int().nonnegative(),
-    completionTokens: z17.number().int().nonnegative(),
-    durationMs: z17.number().int().nonnegative(),
+    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 —
@@ -3712,11 +4125,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)
@@ -3746,9 +4159,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.
@@ -3761,12 +4174,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` /
@@ -3789,10 +4202,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
@@ -3803,10 +4216,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
@@ -3816,10 +4229,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
@@ -3828,10 +4241,30 @@ 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()
+  }),
+  /**
+   * A prompt draft was created, edited, re-filed, sent, or removed. Emitted
+   * on the project stream so a thread picker open in another window folds the
+   * change in. Content-only churn rides this event too (autosave fires it
+   * about once a second per typing user), so consumers must debounce and
+   * should ignore an event for the draft they are themselves editing.
+   *
+   * `gezelId` is the draft's, not the envelope's: a draft that will start a
+   * new thread has no session for the envelope to be scoped by.
+   */
+  z19.object({
+    type: z19.literal("prompt_draft_changed"),
+    projectId: z19.string(),
+    gezelId: z19.string(),
+    draftId: z19.string(),
+    sessionId: z19.string().nullable(),
+    status: z19.enum(["draft", "sent"]),
+    deleted: z19.boolean().optional(),
+    updatedAt: z19.string()
   }),
   /**
    * Global (project-less) signal that Night Shift mode flipped ON/OFF.
@@ -3839,10 +4272,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
@@ -3851,10 +4284,10 @@ 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
@@ -3863,11 +4296,11 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
    * the wallpaper when the user opted in, and the Settings card
    * refreshes its preview.
    */
-  z17.object({
-    type: z17.literal("ambient_dashboard"),
-    state: z17.enum(["started", "ended", "failed"]),
-    generatedAt: z17.string().optional(),
-    filename: z17.string().optional()
+  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 —
@@ -3875,23 +4308,27 @@ 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
@@ -4024,8 +4461,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
@@ -4033,121 +4470,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