@bendyline/gezel 1.0.2 → 1.0.4

package/dist/schemas/index.js

@@ -494,13 +494,14 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     label: z3.string().min(1).optional(),
     artifact: z3.boolean().optional()
   }),
-  /** `file` must NOT match `pattern` (regex). E.g. exclude internal-only release noise. */
+  /** `file` must NOT match `pattern` (regex), in the workspace or artifacts drawer. */
   z3.object({
     kind: z3.literal("notContains"),
     file: z3.string().min(1),
     pattern: z3.string().min(1),
     flags: z3.string().optional(),
-    label: z3.string().min(1).optional()
+    label: z3.string().min(1).optional(),
+    artifact: z3.boolean().optional()
   }),
   /**
    * `file` may use high-risk claim wording only when the exact matched
@@ -643,6 +644,20 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
     tools: z3.array(z3.string().min(1)).min(1),
     minSuccessful: z3.number().int().positive().optional()
   }),
+  /**
+   * A PR-review coverage ledger must name every changed path materialized in
+   * a connector corpus. The ledger is workspace JSON (`reviewedFiles` by
+   * default); the source records live in the read-only artifacts drawer and
+   * carry their authoritative path in frontmatter. This prevents a polished
+   * report from passing after only the first context-sized prefix was read.
+   */
+  z3.object({
+    kind: z3.literal("corpusCoverage"),
+    file: z3.string().min(1),
+    corpusDir: z3.string().min(1),
+    reviewedField: z3.string().min(1).optional(),
+    recordField: z3.string().min(1).optional()
+  }),
   /**
    * The H1 slide titles in `file` must match the numbered slide headings in
    * `outlineFile`, one-for-one and in order. This makes a locked Markdown
@@ -652,7 +667,9 @@ var GateCheckSchema = z3.discriminatedUnion("kind", [
   z3.object({
     kind: z3.literal("markdownHeadingsMatch"),
     file: z3.string().min(1),
-    outlineFile: z3.string().min(1)
+    outlineFile: z3.string().min(1),
+    /** Read outlineFile from artifacts while file uses the check's primary surface. */
+    outlineArtifact: z3.boolean().optional()
   }),
   /**
    * Named facts in `file` must come from authorized sources: each fact
@@ -915,6 +932,12 @@ var AdvanceWhenSchema = z5.object({
   /** Step to activate on the signal. Defaults to `next`; must resolve like `next`. */
   goto: z5.string().optional()
 });
+var CraftbookStepInputSchema = z5.object({
+  /** Path relative to the selected drawer's root. */
+  file: z5.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.")
+});
 var ModelTierSchema = z5.enum(MODEL_TIER_ORDER);
 var CraftbookStepSchema = z5.object({
   id: z5.string().min(1),
@@ -955,6 +978,10 @@ var CraftbookStepSchema = z5.object({
    * 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(
+    "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). */
@@ -966,14 +993,16 @@ var CraftbookStepSchema = z5.object({
    * Marks the parent step that triggers a declarative per-item fanout
    * (see {@link CraftbookSpawnSchema}). When this step activates on a
    * spawn-host task, the runtime reads the craftbook's `spawn.overFile`
-   * workspace JSON array and spawns one child task per item — no model
+   * 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()
 });
 var CraftbookSpawnSchema = z5.object({
-  /** Workspace-relative JSON file the parent produces; its array drives the fanout. */
+  /** Surface-relative JSON file the parent produces; its array drives the fanout. */
   overFile: z5.string().min(1),
+  /** Read overFile from the artifacts drawer instead of the project workspace. */
+  overArtifact: z5.boolean().optional(),
   /** Dotted path to the array inside `overFile`. Absent → the file itself is the array. */
   itemsPath: z5.string().optional(),
   /** Entry step id of the child template. Defaults to the first `steps` entry. */
@@ -1009,6 +1038,14 @@ function validateCraftbookGraph(cb) {
         problems.push(`step "${s.id}" advanceWhen.goto "${s.advanceWhen.goto}" missing from steps`);
       }
     }
+    for (const input of s.consumes ?? []) {
+      if (!input.artifact) continue;
+      if (!/`read_artifact(?:`|\()/.test(s.prompt ?? "")) {
+        problems.push(
+          `step "${s.id}" consumes artifact "${input.file}" but its prompt does not explicitly call \`read_artifact\``
+        );
+      }
+    }
     if (s.gate) {
       const gate = normalizeStepGate(s.gate);
       if (s.terminal && gate.at === "activation") {
@@ -1301,6 +1338,9 @@ var NewCraftbookStepSchema = z5.object({
   assignee: TaskAssigneeSchema.optional(),
   onEnter: ScriptRefListSchema.optional(),
   onExit: ScriptRefListSchema.optional(),
+  consumes: z5.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. */
@@ -1413,6 +1453,7 @@ function resolveSteps(blueprints) {
       ...s.assignee ? { assignee: s.assignee } : {},
       ...s.onEnter ? { onEnter: s.onEnter } : {},
       ...s.onExit ? { onExit: s.onExit } : {},
+      ...s.consumes && s.consumes.length > 0 ? { consumes: s.consumes } : {},
       ...s.advanceWhen ? { advanceWhen: s.advanceWhen } : {},
       ...s.gate ? { gate: s.gate } : {},
       ...s.next ? { next: s.next } : {},
@@ -1535,6 +1576,10 @@ function applyStepPatch(step, patch) {
       delete updated.onExit;
     } else updated.onExit = patch.onExit;
   }
+  if (patch.consumes !== void 0) {
+    if (patch.consumes === null || patch.consumes.length === 0) delete updated.consumes;
+    else updated.consumes = patch.consumes;
+  }
   if (patch.advanceWhen !== void 0) {
     if (patch.advanceWhen === null) delete updated.advanceWhen;
     else updated.advanceWhen = patch.advanceWhen;
@@ -1713,7 +1758,7 @@ function craftbookDocFormatFromEnv(value) {
 }
 
 // src/schemas/craftbook-test.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/schemas/history.ts
 import { z as z18 } from "zod";
@@ -3534,7 +3579,15 @@ var ChatEventSchema = z17.discriminatedUnion("type", [
     kind: z17.string(),
     summary: z17.string(),
     at: z17.string(),
-    taskRef: z17.string().optional()
+    taskRef: z17.string().optional(),
+    /**
+     * Gezel responsible for the event, when History recorded one. Kept
+     * separate from the human-readable summary so fixed-presentation
+     * clients (notably the role-name-only CLI) can render the actor using
+     * their own naming mode instead of leaking the friendly name embedded
+     * in the audit prose.
+     */
+    gezelId: z17.string().optional()
   }),
   /**
    * Emitted when a gezel crosses a growth level threshold and a pending
@@ -4075,444 +4128,9 @@ var ListHistoryResponseSchema = z18.object({
   entries: z18.array(HistoryEntrySchema)
 });
 
-// src/schemas/craftbook-test.ts
-var CRAFTBOOK_TEST_SCHEMA_VERSION = 1;
-var CRAFTBOOK_TEST_FILENAME = "test.json";
-var PrometheusAlertsCheckSchema = z19.object({
-  kind: z19.literal("prometheusAlerts"),
-  file: z19.string().min(1),
-  minRules: z19.number().int().positive().optional(),
-  maxPageAlerts: z19.number().int().nonnegative().optional(),
-  allowedSeverities: z19.array(z19.string().min(1)).optional(),
-  requiredServices: z19.array(z19.string().min(1)).optional(),
-  requiredRunbookUrls: z19.array(z19.string().min(1)).optional()
-}).strict();
-var NodeScriptPassesCheckSchema = z19.object({
-  kind: z19.literal("nodeScriptPasses"),
-  script: z19.string().min(1),
-  timeoutMs: z19.number().int().positive().optional(),
-  requiredOutput: z19.array(
-    z19.object({
-      pattern: z19.string().min(1),
-      flags: z19.string().optional(),
-      label: z19.string().optional()
-    }).strict()
-  ).optional()
-}).strict();
-var BinaryDocumentCheckSchema = z19.object({
-  kind: z19.literal("binaryDocument"),
-  file: z19.string().min(1),
-  /** Look in the artifacts drawer instead of the workspace. */
-  artifact: z19.boolean().optional(),
-  /** Floor on the container's byte length; defaults to 1000. */
-  minBytes: z19.number().int().positive().optional()
-}).strict();
-var CraftbookTestCheckSchema = z19.union([
-  GateCheckSchema,
-  PrometheusAlertsCheckSchema,
-  NodeScriptPassesCheckSchema,
-  BinaryDocumentCheckSchema
-]);
-var MockServiceIdSchema = z19.string().min(1).regex(/^[a-z0-9][a-z0-9-]*$/, "mock service ids are lowercase kebab-case");
-var MockToolsetIdSchema = z19.string().min(1).regex(
-  /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/,
-  "mock toolset ids are lowercase catalog ids or scoped npm-style ids"
-);
-var MockHttpRouteSchema = z19.object({
-  method: z19.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("GET"),
-  /** Exact path, `:param` segments, or a trailing `*` wildcard. */
-  path: z19.string().min(1),
-  status: z19.number().int().min(100).max(599).default(200),
-  headers: z19.record(z19.string(), z19.string()).optional(),
-  /** String bodies are served verbatim; anything else is JSON-encoded. */
-  body: z19.unknown(),
-  latencyMs: z19.number().int().nonnegative().optional()
-}).strict();
-var MockServiceSchema = z19.discriminatedUnion("kind", [
-  z19.object({
-    kind: z19.literal("http"),
-    id: MockServiceIdSchema,
-    description: z19.string().min(1),
-    /**
-     * v1 mock HTTP is reachable ONLY through the `http.authed`
-     * credential rail (anonymous script/browser HTTP hard-rejects
-     * loopback), so a credential is required. The harness seeds it and
-     * grants the mock's exact origin on the trial project.
-     */
-    credential: z19.object({
-      name: z19.string().regex(/^mock\.[a-z0-9][a-z0-9.-]*$/, "mock credentials are named mock.<service-id>"),
-      authScheme: z19.enum(["bearer", "basic"]).optional()
-    }).strict(),
-    routes: z19.array(MockHttpRouteSchema).min(1)
-  }).strict(),
-  z19.object({
-    kind: z19.literal("webhook"),
-    id: MockServiceIdSchema,
-    description: z19.string().min(1),
-    /** Receiver path; defaults to `/webhook` when omitted. */
-    path: z19.string().min(1).optional()
-  }).strict(),
-  z19.object({
-    kind: z19.literal("cli"),
-    id: MockServiceIdSchema,
-    description: z19.string().min(1),
-    /** Fake-CLI shim seeded as a workspace file (today's dry-run pattern). */
-    shim: z19.object({ path: z19.string().min(1), content: z19.string() }).strict()
-  }).strict(),
-  z19.object({
-    kind: z19.literal("mcp"),
-    id: MockServiceIdSchema,
-    description: z19.string().min(1),
-    /** Override the local-catalog id when the mock replaces a real dependency. */
-    toolsetId: MockToolsetIdSchema.optional(),
-    /**
-     * Served live by the eval mock rail: each declared tool becomes a
-     * real tool on a per-trial Streamable-HTTP MCP endpoint, installed
-     * into the trial via a local-catalog `mock-mcp-<id>` toolset.
-     * `resultTemplate` is JSON-encoded as the tool result text
-     * (default `{"ok":true}` when absent).
-     */
-    tools: z19.array(
-      z19.object({
-        name: z19.string().min(1),
-        description: z19.string().min(1),
-        resultTemplate: z19.unknown().optional(),
-        /** Deterministic stateful responses, consumed in call order; the last repeats. */
-        resultSequence: z19.array(z19.unknown()).min(1).optional(),
-        /**
-         * Deterministic eval-only file materialization after this
-         * tool call. The fixture must match the container the
-         * deliverable's extension claims — a `minimal-pptx` written
-         * to a `.docx` path now fails the `binaryDocument` check on
-         * content type rather than sliding through a byte floor.
-         */
-        writeFixture: z19.object({
-          surface: z19.enum(["workspace", "artifact"]),
-          pathArgument: z19.string().min(1),
-          fixture: z19.enum(["minimal-pptx", "minimal-docx", "minimal-pdf", "minimal-png"])
-        }).strict().optional()
-      }).strict()
-    ).min(1)
-  }).strict()
-]);
-var CraftbookTestFixtureFileSchema = z19.object({
-  path: z19.string().min(1),
-  content: z19.string(),
-  /** Defaults to `workspace`; `harness` never enters the model-visible project. */
-  surface: z19.enum(["workspace", "artifact", "harness"]).optional(),
-  /**
-   * Whether the fixture is presented to the model as source material.
-   * Defaults to true; false still seeds the file for browsers and graders.
-   */
-  modelInput: z19.boolean().optional()
-}).strict();
-var CraftbookTestWorkerSchema = z19.object({
-  name: z19.string().min(1),
-  role: z19.string().min(1),
-  description: z19.string().optional(),
-  about: z19.string().optional()
-}).strict();
-var CraftbookTestSetupSchema = z19.object({
-  projectName: z19.string().min(1),
-  about: z19.string().optional(),
-  missionObjectives: z19.string().optional(),
-  files: z19.array(CraftbookTestFixtureFileSchema).default([]),
-  /** Exact values supplied to the catalog craftbook's `paramSchema`. */
-  craftbookParams: z19.record(z19.string(), z19.string()).optional(),
-  /**
-   * Direct execution target. When present the harness seeds this gezel
-   * and sends the kickoff straight to it (measuring whether the book
-   * guides the work); absent → the Meester routes.
-   */
-  worker: CraftbookTestWorkerSchema.optional()
-}).strict();
-var CraftbookTestDeliverableSchema = z19.object({
-  path: z19.string().min(1),
-  kind: DeliverableKindSchema,
-  minBytes: z19.number().int().positive().optional(),
-  checks: z19.array(CraftbookTestCheckSchema).optional()
-}).strict();
-var CraftbookTestMockExpectationSchema = z19.object({
-  /** Mock service id from `mocks[]`. */
-  service: MockServiceIdSchema,
-  minRequests: z19.number().int().positive().optional(),
-  /** Regex sources matched against logged request paths. */
-  requiredPaths: z19.array(z19.string().min(1)).optional(),
-  forbiddenPaths: z19.array(z19.string().min(1)).optional(),
-  /**
-   * Exact MCP tool names that must each have been called at least once
-   * on this service (`kind: 'mcp'` only). Exact names, not regexes —
-   * the tool roster is fully declared in the same file, so a pattern
-   * buys nothing and invites drift. Cross-checked against the mock's
-   * declared `tools[]` at parse time.
-   */
-  requiredTools: z19.array(z19.string().min(1)).optional(),
-  /** Per-MCP-tool call budgets for repeated journeys or retries. */
-  toolCalls: z19.record(
-    z19.string().min(1),
-    z19.object({
-      minCalls: z19.number().int().nonnegative().default(1),
-      maxCalls: z19.number().int().nonnegative().optional()
-    }).strict().refine(
-      (value) => value.maxCalls === void 0 || value.minCalls <= value.maxCalls,
-      "minCalls must be less than or equal to maxCalls"
-    )
-  ).optional()
-}).strict();
-var CraftbookTestHistoryExpectationSchema = z19.object({
-  kind: HistoryEventKindSchema,
-  minEntries: z19.number().int().nonnegative().default(1),
-  maxEntries: z19.number().int().nonnegative().optional(),
-  summaryPattern: z19.string().min(1).optional(),
-  flags: z19.string().optional(),
-  details: z19.record(z19.string(), z19.union([z19.string(), z19.number(), z19.boolean(), z19.null()])).optional()
-}).strict();
-var CraftbookTestSuccessSchema = z19.object({
-  summary: z19.string().min(1),
-  deliverables: z19.array(CraftbookTestDeliverableSchema).optional(),
-  checks: z19.array(CraftbookTestCheckSchema).optional(),
-  taskNotes: z19.object({
-    minBytes: z19.number().int().positive().optional(),
-    checks: z19.array(CraftbookTestCheckSchema).optional(),
-    requireCraftbookTask: z19.boolean().optional()
-  }).strict().optional(),
-  taskGraph: z19.object({
-    checks: z19.array(CraftbookTestCheckSchema).optional(),
-    requireCraftbookTask: z19.boolean().optional(),
-    /** Require the matching task to reach a terminal step (or complete). */
-    requireTerminalStep: z19.boolean().optional(),
-    requireDraftRef: z19.boolean().optional(),
-    draft: z19.object({
-      status: z19.enum(["draft", "paused", "active", "complete", "canceled"]).optional(),
-      minDescriptionBytes: z19.number().int().positive().optional(),
-      minOutcomes: z19.number().int().positive().optional(),
-      minSteps: z19.number().int().positive().optional(),
-      requireTerminalVerification: z19.boolean().optional(),
-      requireGatedBuildSteps: z19.boolean().optional()
-    }).strict().optional()
-  }).strict().optional(),
-  /** Assertions evaluated against the live mock server's request log. */
-  mocks: z19.array(CraftbookTestMockExpectationSchema).optional(),
-  /** Assertions evaluated against the project's append-only History log. */
-  history: z19.array(CraftbookTestHistoryExpectationSchema).optional(),
-  /** Workspace fixtures whose final content must equal the seeded bytes exactly. */
-  unchangedFixtures: z19.array(z19.string().min(1)).optional()
-}).strict();
-var CraftbookTestRubricSchema = z19.object({
-  artifact: z19.object({
-    /** Workspace or artifact path the judge reads (adapter derives the basename). */
-    path: z19.string().min(1),
-    kind: z19.enum(["html", "markdown", "yaml", "typescript", "json", "text"])
-  }).strict(),
-  axes: z19.array(z19.object({ name: z19.string().min(1), description: z19.string().min(1) }).strict()).min(1),
-  contextNote: z19.string().optional()
-}).strict();
-var CraftbookTestSpecSchema = z19.object({
-  schemaVersion: z19.literal(CRAFTBOOK_TEST_SCHEMA_VERSION),
-  title: z19.string().min(1),
-  objective: z19.string().min(1),
-  /**
-   * Task-class taxonomy tags (e.g. `html-game`, `corpus`, `external`).
-   * The single declared source for harness selection and batch
-   * planning — replaces the old regex classifiers.
-   */
-  tags: z19.array(z19.string().min(1)).default([]),
-  /** Kickoff chat message the harness sends. Required — every book runs. */
-  prompt: z19.string().min(1),
-  setup: CraftbookTestSetupSchema,
-  mocks: z19.array(MockServiceSchema).default([]),
-  success: CraftbookTestSuccessSchema,
-  rubric: CraftbookTestRubricSchema,
-  qualityFocus: z19.array(z19.string().min(1)).default([]),
-  /**
-   * Sanctioned escape hatch for experiments — carried opaquely, never
-   * interpreted by CI. Promote a field out of here before relying on it.
-   */
-  extensions: z19.record(z19.string(), z19.unknown()).optional()
-}).strict().superRefine((spec, ctx) => {
-  const mockIds = new Set(spec.mocks.map((m) => m.id));
-  const mockById = new Map(spec.mocks.map((m) => [m.id, m]));
-  for (const [i, expectation] of (spec.success.mocks ?? []).entries()) {
-    if (!mockIds.has(expectation.service)) {
-      ctx.addIssue({
-        code: z19.ZodIssueCode.custom,
-        path: ["success", "mocks", i, "service"],
-        message: `success.mocks[${i}] references unknown mock service "${expectation.service}"`
-      });
-    }
-    if (expectation.requiredTools && expectation.requiredTools.length > 0) {
-      const target = mockById.get(expectation.service);
-      if (target && target.kind !== "mcp") {
-        ctx.addIssue({
-          code: z19.ZodIssueCode.custom,
-          path: ["success", "mocks", i, "requiredTools"],
-          message: `success.mocks[${i}].requiredTools requires an mcp service; "${expectation.service}" is kind "${target.kind}"`
-        });
-      } else if (target?.kind === "mcp") {
-        const declared = new Set(target.tools.map((tool) => tool.name));
-        for (const name of expectation.requiredTools) {
-          if (!declared.has(name)) {
-            ctx.addIssue({
-              code: z19.ZodIssueCode.custom,
-              path: ["success", "mocks", i, "requiredTools"],
-              message: `success.mocks[${i}].requiredTools names undeclared tool "${name}" on mcp service "${expectation.service}"`
-            });
-          }
-        }
-      }
-    }
-    if (expectation.toolCalls && Object.keys(expectation.toolCalls).length > 0) {
-      const target = mockById.get(expectation.service);
-      if (target && target.kind !== "mcp") {
-        ctx.addIssue({
-          code: z19.ZodIssueCode.custom,
-          path: ["success", "mocks", i, "toolCalls"],
-          message: `success.mocks[${i}].toolCalls requires an mcp service; "${expectation.service}" is kind "${target.kind}"`
-        });
-      } else if (target?.kind === "mcp") {
-        const declared = new Set(target.tools.map((tool) => tool.name));
-        for (const name of Object.keys(expectation.toolCalls)) {
-          if (!declared.has(name)) {
-            ctx.addIssue({
-              code: z19.ZodIssueCode.custom,
-              path: ["success", "mocks", i, "toolCalls", name],
-              message: `success.mocks[${i}].toolCalls names undeclared tool "${name}" on mcp service "${expectation.service}"`
-            });
-          }
-        }
-      }
-    }
-  }
-  for (const [i, mock] of spec.mocks.entries()) {
-    if (mock.kind === "http" && mock.credential.name !== `mock.${mock.id}`) {
-      ctx.addIssue({
-        code: z19.ZodIssueCode.custom,
-        path: ["mocks", i, "credential", "name"],
-        message: `http mock "${mock.id}" must use credential name "mock.${mock.id}"`
-      });
-    }
-  }
-  const workspaceFixtures = new Set(
-    spec.setup.files.filter((file) => file.surface === void 0 || file.surface === "workspace").map((file) => file.path)
-  );
-  for (const [i, path] of (spec.success.unchangedFixtures ?? []).entries()) {
-    if (!workspaceFixtures.has(path)) {
-      ctx.addIssue({
-        code: z19.ZodIssueCode.custom,
-        path: ["success", "unchangedFixtures", i],
-        message: `unchanged fixture "${path}" is not a seeded workspace file`
-      });
-    }
-  }
-  for (const [i, expectation] of (spec.success.history ?? []).entries()) {
-    if (expectation.maxEntries !== void 0 && expectation.minEntries > expectation.maxEntries) {
-      ctx.addIssue({
-        code: z19.ZodIssueCode.custom,
-        path: ["success", "history", i],
-        message: "minEntries must be less than or equal to maxEntries"
-      });
-    }
-  }
-});
-function parseCraftbookTestSpec(raw, opts) {
-  const mode = opts?.mode ?? "strict";
-  const candidate = mode === "tolerant" ? deepStripUnknown(raw) : raw;
-  const parsed = CraftbookTestSpecSchema.safeParse(candidate);
-  if (parsed.success) return { ok: true, spec: parsed.data };
-  return {
-    ok: false,
-    errors: parsed.error.issues.map((issue) => {
-      const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "<root>";
-      return `${path}: ${issue.message}`;
-    })
-  };
-}
-function deepStripUnknown(raw) {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
-  const record = structuredClone(raw);
-  const version = record.schemaVersion;
-  if (typeof version === "number" && Number.isInteger(version) && version > CRAFTBOOK_TEST_SCHEMA_VERSION) {
-    record.schemaVersion = CRAFTBOOK_TEST_SCHEMA_VERSION;
-  }
-  for (let pass = 0; pass < 16; pass++) {
-    const attempt = CraftbookTestSpecSchema.safeParse(record);
-    if (attempt.success) return record;
-    const unknownKeyIssues = attempt.error.issues.filter(
-      (issue) => issue.code === z19.ZodIssueCode.unrecognized_keys
-    );
-    if (unknownKeyIssues.length === 0) return record;
-    for (const issue of unknownKeyIssues) {
-      const target = resolvePath(record, issue.path);
-      if (target && typeof target === "object" && !Array.isArray(target)) {
-        for (const key of issue.keys) delete target[key];
-      }
-    }
-  }
-  return record;
-}
-function resolvePath(root, path) {
-  let node = root;
-  for (const segment of path) {
-    if (node === null || typeof node !== "object") return void 0;
-    node = node[segment];
-  }
-  return node;
-}
-
-// src/schemas/codex-setup.ts
-import { z as z20 } from "zod";
-var CodexSetupModelOptionSchema = z20.object({
-  id: z20.string().min(1),
-  label: z20.string().min(1),
-  description: z20.string().optional(),
-  kind: z20.enum(["gezel", "model"]).default("model"),
-  provider: z20.string().min(1),
-  /** Stable gezel id for persona-backed entries. Absent on raw-model entries. */
-  gezelId: z20.string().min(1).optional(),
-  role: z20.string().min(1).optional(),
-  /** Human-readable name of the effective inference model behind a gezel. */
-  modelLabel: z20.string().min(1).optional(),
-  contextWindow: z20.number().int().positive().optional(),
-  supportsReasoning: z20.boolean().optional(),
-  supportsTools: z20.boolean().optional()
-});
-var CodexSetupStateSchema = z20.enum([
-  "not-configured",
-  "configured",
-  "update-needed",
-  "conflict",
-  "unavailable"
-]);
-var CodexSetupStatusResponseSchema = z20.object({
-  state: CodexSetupStateSchema,
-  models: z20.array(CodexSetupModelOptionSchema),
-  configuredModel: z20.string().optional(),
-  recommendedModel: z20.string().optional(),
-  reasons: z20.array(z20.string()),
-  message: z20.string().optional(),
-  codexInstalled: z20.boolean(),
-  codexVersion: z20.string().optional(),
-  codexPath: z20.string().optional(),
-  endpointsEnabled: z20.boolean(),
-  profileName: z20.string().min(1),
-  profilePath: z20.string().min(1),
-  launchCommand: z20.string().min(1),
-  bridge: z20.object({
-    baseUrl: z20.string().url(),
-    listening: z20.boolean(),
-    port: z20.number().int().nonnegative()
-  }),
-  canConfigure: z20.boolean(),
-  /** Whether Gezel-owned credential/state material exists and can be safely removed. */
-  canRemove: z20.boolean()
-});
-var ConfigureCodexRequestSchema = z20.object({
-  model: z20.string().min(1)
-});
-
 // src/schemas/project.ts
-import { z as z21 } from "zod";
-var HttpsOriginSchema = z21.string().url().refine(
+import { z as z19 } from "zod";
+var HttpsOriginSchema = z19.string().url().refine(
   (value) => {
     try {
       const url = new URL(value);
@@ -4523,7 +4141,7 @@ var HttpsOriginSchema = z21.string().url().refine(
   },
   { message: "must be an exact HTTPS origin (for example https://api.example.com)" }
 );
-var ProjectGitHubSchema = z21.object({
+var ProjectGitHubSchema = z19.object({
   // Accept any non-empty string. Git URLs come in many forms beyond
   // `https://`: ssh shorthand (`git@github.com:owner/repo`), local
   // filesystem paths (`/path/to/bare.git`), other-host references.
@@ -4531,89 +4149,89 @@ var ProjectGitHubSchema = z21.object({
   // and broke Phase-3 worktree tests that use a local bare repo as
   // the upstream. Higher layers (the github sync code) parse the URL
   // and reject anything that doesn't shape up as a clonable ref.
-  url: z21.string().min(1),
-  branch: z21.string().optional(),
+  url: z19.string().min(1),
+  branch: z19.string().optional(),
   /** Resolved absolute path to the working tree. Managed by the service. */
-  checkoutDir: z21.string().optional(),
-  lastSyncedAt: z21.string().optional(),
+  checkoutDir: z19.string().optional(),
+  lastSyncedAt: z19.string().optional(),
   /** Repo default branch (e.g. "main"), detected lazily and cached. Managed by the service. */
-  defaultBranch: z21.string().optional()
+  defaultBranch: z19.string().optional()
 });
-var ProjectConnectorBindingSchema = z21.object({
+var ProjectConnectorBindingSchema = z19.object({
   /** Stable binding id; also the SecretStore `fieldId` + corpus-slug seed. */
-  id: z21.string().min(1),
+  id: z19.string().min(1),
   /** The connector-type catalog id, e.g. `mail-gmail`, `linear-issues`. */
-  type: z21.string().min(1),
+  type: z19.string().min(1),
   /** Catalog source the type resolved from (provenance/pin). */
-  sourceId: z21.string().optional(),
+  sourceId: z19.string().optional(),
   /** Pinned connector-type version. */
-  version: z21.string().optional(),
-  displayName: z21.string().optional(),
+  version: z19.string().optional(),
+  displayName: z19.string().optional(),
   /**
    * Artifact-relative corpus root (`data/<corpusName>`), resolved once at bind
    * time and never recomputed — renaming a binding must not strand its corpus.
    */
-  corpusDir: z21.string().optional(),
+  corpusDir: z19.string().optional(),
   /** Per-binding config, validated at bind time against the type's `configSchema`. */
-  config: z21.record(z21.string(), z21.unknown()).default({}),
+  config: z19.record(z19.string(), z19.unknown()).default({}),
   /** Opaque, adapter-shaped incremental-sync cursor. Persisted so resync resumes. */
-  cursor: z21.unknown().optional(),
+  cursor: z19.unknown().optional(),
   /** Pause syncing without unbinding. */
-  disabled: z21.boolean().optional(),
-  lastSyncedAt: z21.string().optional(),
+  disabled: z19.boolean().optional(),
+  lastSyncedAt: z19.string().optional(),
   /** Last sync error, surfaced in the UI; cleared on the next success. */
-  lastError: z21.string().optional()
+  lastError: z19.string().optional()
 });
-var ProjectNudgeConfigSchema = z21.object({
-  enabled: z21.boolean().optional(),
-  rapidIntervalMs: z21.number().int().positive().optional(),
-  slowIntervalMs: z21.number().int().positive().optional(),
-  recentActivityWindowMs: z21.number().int().positive().optional(),
-  rapidAttemptsBeforeBackoff: z21.number().int().positive().optional(),
+var ProjectNudgeConfigSchema = z19.object({
+  enabled: z19.boolean().optional(),
+  rapidIntervalMs: z19.number().int().positive().optional(),
+  slowIntervalMs: z19.number().int().positive().optional(),
+  recentActivityWindowMs: z19.number().int().positive().optional(),
+  rapidAttemptsBeforeBackoff: z19.number().int().positive().optional(),
   /**
    * Grace period applied to the very first nudge a project ever
    * receives, measured from `project.createdAt`. Default per tempo;
    * setting `0` opts out (legacy behavior — first nudge fires as
    * soon as the rapid interval allows).
    */
-  firstNudgeGraceMs: z21.number().int().nonnegative().optional()
+  firstNudgeGraceMs: z19.number().int().nonnegative().optional()
 });
-var ProjectNudgeStateSchema = z21.object({
-  lastNudgedAt: z21.string().optional(),
-  consecutiveRapidNudges: z21.number().int().nonnegative().optional()
+var ProjectNudgeStateSchema = z19.object({
+  lastNudgedAt: z19.string().optional(),
+  consecutiveRapidNudges: z19.number().int().nonnegative().optional()
 });
-var ProjectTabVisibilitySchema = z21.object({
-  overview: z21.boolean().optional(),
-  tasks: z21.boolean().optional(),
-  approvals: z21.boolean().optional(),
-  workspace: z21.boolean().optional(),
-  artifacts: z21.boolean().optional(),
-  map: z21.boolean().optional()
+var ProjectTabVisibilitySchema = z19.object({
+  overview: z19.boolean().optional(),
+  tasks: z19.boolean().optional(),
+  approvals: z19.boolean().optional(),
+  workspace: z19.boolean().optional(),
+  artifacts: z19.boolean().optional(),
+  map: z19.boolean().optional()
 }).strict();
-var ProjectManagedWorkspaceWritePolicySchema = z21.enum(["auto", "allow", "deny"]);
-var ProjectTypeProvenanceSchema = z21.object({
+var ProjectManagedWorkspaceWritePolicySchema = z19.enum(["auto", "allow", "deny"]);
+var ProjectTypeProvenanceSchema = z19.object({
   /** Catalog id of the applied project type. */
-  id: z21.string(),
+  id: z19.string(),
   /** Type version installed at adoption. */
-  version: z21.string(),
+  version: z19.string(),
   /** Catalog source the type resolved from (`bundled` | `local` | `community` | …). */
-  source: z21.string(),
+  source: z19.string(),
   /** Param values collected at adoption, substituted into templates + seed files. */
-  params: z21.record(z21.string(), z21.unknown()).optional(),
+  params: z19.record(z19.string(), z19.unknown()).optional(),
   /** ISO timestamp of adoption. */
-  appliedAt: z21.string()
+  appliedAt: z19.string()
 });
-var ProjectSchema = z21.object({
+var ProjectSchema = z19.object({
   id: EntityIdSchema,
-  name: z21.string(),
-  description: z21.string().optional(),
-  workingDir: z21.string().optional(),
+  name: z19.string(),
+  description: z19.string().optional(),
+  workingDir: z19.string().optional(),
   /** Optional gezel that acts as the project's voorman (foreman). Surfaces in
    *  the project detail pane, flows into the system prompt when a session is
    *  scoped here. For solo projects (`mode === 'solo'`) this same field
-   *  holds the project's ambachtsman — the data is unchanged, only the
+   *  holds the project's Builder — the data is unchanged, only the
    *  label flips. */
-  voormanGezelId: z21.string().optional(),
+  voormanGezelId: z19.string().optional(),
   /**
    * Internal marker: ISO timestamp of the one-time automatic voorman
    * assignment. The indexer ensures every project ends up with a voorman
@@ -4623,7 +4241,7 @@ var ProjectSchema = z21.object({
    * silently re-populated on the next scan. Not user-editable; absent on
    * projects last written before this field existed.
    */
-  voormanAutoAssignedAt: z21.string().optional(),
+  voormanAutoAssignedAt: z19.string().optional(),
   /**
    * Roster — gezels that have been pulled into this project. Populated
    * automatically the first time a gezel is set as voorman, opens a
@@ -4638,7 +4256,7 @@ var ProjectSchema = z21.object({
    * (back-compat with every project written before this field
    * existed).
    */
-  gezelIds: z21.array(z21.string()).optional(),
+  gezelIds: z19.array(z19.string()).optional(),
   /**
    * Suggested-work keys the user has dismissed ("don't offer this again
    * here"). Advisory UI state, same spirit as `gezelIds`: enabling a
@@ -4648,7 +4266,7 @@ var ProjectSchema = z21.object({
    * `project-type:<typeId>:<scheduleKey>`). Deliberately not exposed
    * through the model-facing `update_project` MCP tool.
    */
-  suggestedWorkDismissed: z21.array(z21.string()).optional(),
+  suggestedWorkDismissed: z19.array(z19.string()).optional(),
   /**
    * Shared per-project configuration values ("project properties") that
    * craftbook params and features draw from — e.g. `content.language`,
@@ -4657,26 +4275,26 @@ var ProjectSchema = z21.object({
    * ids are allowed (the registry improves display, it doesn't gate).
    * Values are plain strings; empty string is treated as unset.
    */
-  properties: z21.record(z21.string(), z21.string()).optional(),
+  properties: z19.record(z19.string(), z19.string()).optional(),
   /**
    * Project shape. `crew` (the default) is the original behavior — the
    * voorman recruits and coordinates a team of specialists. `solo` is a
-   * "job" — a single specialist (the ambachtsman, stored in
+   * "job" — a single Builder (stored in
    * `voormanGezelId`) handles the whole project themselves; team-
    * management MCP tools are stripped from their session, and the
    * Meester is instructed not to nominate other gezels. Missing → `crew`
    * for back-compat with every project on disk before this field
    * existed.
    */
-  mode: z21.enum(["crew", "solo"]).optional(),
+  mode: z19.enum(["crew", "solo"]).optional(),
   /**
    * Optional custom label for this project's lead gezel, overriding the
-   * mode-based default ("Voorman" / "Ambachtsman") everywhere the UI
+   * mode-based default ("Voorman" / "Builder") everywhere the UI
    * renders it. Set by a project type at adoption (e.g. checkers →
    * "Opponent"); absent → the mode default. The data field stays
    * `voormanGezelId` — only the label changes.
    */
-  leadLabel: z21.string().optional(),
+  leadLabel: z19.string().optional(),
   /**
    * Lean-agent profile (set by a project type at adoption, e.g. checkers).
    * When true, sessions here get a minimal tool surface (the type's script
@@ -4684,7 +4302,7 @@ var ProjectSchema = z21.object({
    * scaffolding). Keeps small local models from being overwhelmed on a
    * focused single-purpose task. Absent → the full agent profile.
    */
-  leanProfile: z21.boolean().optional(),
+  leanProfile: z19.boolean().optional(),
   /**
    * Per-project workspace-indexing switch. Missing/true preserves the
    * historical behavior: structural discovery plus the content-index refresh
@@ -4697,9 +4315,9 @@ var ProjectSchema = z21.object({
    * document index. Project-type manifests may seed the value at adoption and
    * the user can override it later in Project Settings.
    */
-  indexingEnabled: z21.boolean().optional(),
+  indexingEnabled: z19.boolean().optional(),
   github: ProjectGitHubSchema.optional(),
-  connectors: z21.array(ProjectConnectorBindingSchema).optional(),
+  connectors: z19.array(ProjectConnectorBindingSchema).optional(),
   nudgeConfig: ProjectNudgeConfigSchema.optional(),
   nudgeState: ProjectNudgeStateSchema.optional(),
   /**
@@ -4722,7 +4340,7 @@ var ProjectSchema = z21.object({
    * @deprecated Use `managedWorkspaceWritePolicy` and the centralized
    * `projectManagedWorkspaceWritable` resolver.
    */
-  allowGezelWrites: z21.boolean().optional(),
+  allowGezelWrites: z19.boolean().optional(),
   /**
    * Per-project Codex execution posture selected from the project status bar.
    * It overrides per-gezel/install Codex defaults so the visible control is
@@ -4759,7 +4377,7 @@ var ProjectSchema = z21.object({
    *   weak local model having to take an explicit action. Reversible and
    *   non-destructive; chat and direct tool calls keep working.
    */
-  status: z21.enum(["active", "readonly", "inactive", "stable"]).optional(),
+  status: z19.enum(["active", "readonly", "inactive", "stable"]).optional(),
   /**
    * Bury this project in the navigation without deleting it. Archived
    * projects remain available from the dedicated section in the full
@@ -4769,13 +4387,13 @@ var ProjectSchema = z21.object({
    * Missing/false means visible in the ordinary project UX, preserving
    * compatibility with projects written before archiving existed.
    */
-  archived: z21.boolean().optional(),
+  archived: z19.boolean().optional(),
   /**
    * Per-project override of the `run_nodejs_script` wall-clock
    * timeout. Clamped between 30 seconds and 30 minutes. Missing →
    * the service-side default (5 min) applies.
    */
-  workspaceScriptTimeoutMs: z21.number().int().min(3e4).max(30 * 6e4).optional(),
+  workspaceScriptTimeoutMs: z19.number().int().min(3e4).max(30 * 6e4).optional(),
   /**
    * Named credentials this project is explicitly allowed to use.
    * Credentials are stored once globally in `SecretStore`; a grant
@@ -4784,76 +4402,515 @@ var ProjectSchema = z21.object({
    * Missing → no credentials granted. See `scripts/dispatcher.ts`
    * and `secrets/registry.ts` for resolution.
    */
-  grantedCredentials: z21.array(z21.string()).optional(),
+  grantedCredentials: z19.array(z19.string()).optional(),
+  /**
+   * Advanced exact-origin bindings for toolset credentials. Built-in provider
+   * credentials are service-pinned and webhook credentials follow the
+   * configured webhook URL, so entries for those names are ignored.
+   */
+  credentialAllowedOrigins: z19.record(z19.string(), z19.array(HttpsOriginSchema)).optional(),
+  /**
+   * Explicit user override of the project's type (an id from the bundled
+   * project-type taxonomy, see `project-types/taxonomy.ts`). When set, it
+   * wins over `detectedProjectType` for craftbook suggestions. Cleared
+   * (unset) → fall back to auto-detection. Missing on every project written
+   * before this field existed.
+   */
+  projectTypeId: z19.string().optional(),
+  /**
+   * Auto-detected project type, recomputed on each content-index scan from
+   * the workspace file mix + about/mission text. Not user-editable — the
+   * user expresses an override via `projectTypeId`. Absent until the first
+   * scan classifies the project (or when nothing scores above the floor).
+   */
+  detectedProjectType: z19.object({
+    id: z19.string(),
+    score: z19.number(),
+    scannedAt: z19.string()
+  }).optional(),
+  /**
+   * Provenance of an applied custom project type (see docs/project-types.md).
+   * Distinct from `projectTypeId`, which is the taxonomy id used for craftbook
+   * suggestion: a custom type stamps this on adoption and, when it `extends` a
+   * taxonomy id, ALSO sets `projectTypeId` so detection-based suggestion
+   * inherits. Absent on projects created without a custom type.
+   */
+  projectType: ProjectTypeProvenanceSchema.optional(),
+  /**
+   * Filesystem ownership boundary. Missing/`user` is ordinary per-account
+   * state. `machine-shared` is a grandfathered project mounted from the
+   * installer-managed shared root and operated on by this user's daemon.
+   * The engine broker never opens the project or receives its paths.
+   */
+  storageScope: z19.enum(["user", "machine-shared"]).optional(),
+  createdAt: z19.string(),
+  updatedAt: z19.string()
+});
+function resolveProjectTypeId(project) {
+  return project.projectTypeId ?? project.detectedProjectType?.id;
+}
+function projectAllowsAmbientWork(project) {
+  const status = project.status ?? "active";
+  return status === "active";
+}
+var InstalledPackageSchema = z19.object({
+  name: z19.string(),
+  version: z19.string()
+});
+var ProjectDetailSchema = ProjectSchema.extend({
+  packages: z19.array(InstalledPackageSchema),
+  /** Contents of `documents/about.md` inside the project, if present. */
+  about: z19.string().optional(),
+  /** Contents of `documents/missionObjectives.md`, if present. */
+  missionObjectives: z19.string().optional()
+});
+var ProjectFileEntrySchema = z19.object({
+  name: z19.string(),
+  path: z19.string(),
+  isDirectory: z19.boolean(),
+  /** File mtime (ms epoch). Populated only when the caller opts into stats. */
+  mtimeMs: z19.number().optional()
+});
+var ProjectGithubSchema = ProjectGitHubSchema;
+
+// src/schemas/craftbook-test.ts
+var CRAFTBOOK_TEST_SCHEMA_VERSION = 1;
+var CRAFTBOOK_TEST_FILENAME = "test.json";
+var PrometheusAlertsCheckSchema = z20.object({
+  kind: z20.literal("prometheusAlerts"),
+  file: z20.string().min(1),
+  minRules: z20.number().int().positive().optional(),
+  maxPageAlerts: z20.number().int().nonnegative().optional(),
+  allowedSeverities: z20.array(z20.string().min(1)).optional(),
+  requiredServices: z20.array(z20.string().min(1)).optional(),
+  requiredRunbookUrls: z20.array(z20.string().min(1)).optional()
+}).strict();
+var NodeScriptPassesCheckSchema = z20.object({
+  kind: z20.literal("nodeScriptPasses"),
+  script: z20.string().min(1),
+  timeoutMs: z20.number().int().positive().optional(),
+  requiredOutput: z20.array(
+    z20.object({
+      pattern: z20.string().min(1),
+      flags: z20.string().optional(),
+      label: z20.string().optional()
+    }).strict()
+  ).optional()
+}).strict();
+var BinaryDocumentCheckSchema = z20.object({
+  kind: z20.literal("binaryDocument"),
+  file: z20.string().min(1),
+  /** Look in the artifacts drawer instead of the workspace. */
+  artifact: z20.boolean().optional(),
+  /** Floor on the container's byte length; defaults to 1000. */
+  minBytes: z20.number().int().positive().optional()
+}).strict();
+var CraftbookTestCheckSchema = z20.union([
+  GateCheckSchema,
+  PrometheusAlertsCheckSchema,
+  NodeScriptPassesCheckSchema,
+  BinaryDocumentCheckSchema
+]);
+var MockServiceIdSchema = z20.string().min(1).regex(/^[a-z0-9][a-z0-9-]*$/, "mock service ids are lowercase kebab-case");
+var MockToolsetIdSchema = z20.string().min(1).regex(
+  /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/,
+  "mock toolset ids are lowercase catalog ids or scoped npm-style ids"
+);
+var MockHttpRouteSchema = z20.object({
+  method: z20.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("GET"),
+  /** Exact path, `:param` segments, or a trailing `*` wildcard. */
+  path: z20.string().min(1),
+  status: z20.number().int().min(100).max(599).default(200),
+  headers: z20.record(z20.string(), z20.string()).optional(),
+  /** String bodies are served verbatim; anything else is JSON-encoded. */
+  body: z20.unknown(),
+  latencyMs: z20.number().int().nonnegative().optional()
+}).strict();
+var MockServiceSchema = z20.discriminatedUnion("kind", [
+  z20.object({
+    kind: z20.literal("http"),
+    id: MockServiceIdSchema,
+    description: z20.string().min(1),
+    /**
+     * v1 mock HTTP is reachable ONLY through the `http.authed`
+     * credential rail (anonymous script/browser HTTP hard-rejects
+     * loopback), so a credential is required. The harness seeds it and
+     * grants the mock's exact origin on the trial project.
+     */
+    credential: z20.object({
+      name: z20.string().regex(/^mock\.[a-z0-9][a-z0-9.-]*$/, "mock credentials are named mock.<service-id>"),
+      authScheme: z20.enum(["bearer", "basic"]).optional()
+    }).strict(),
+    routes: z20.array(MockHttpRouteSchema).min(1)
+  }).strict(),
+  z20.object({
+    kind: z20.literal("webhook"),
+    id: MockServiceIdSchema,
+    description: z20.string().min(1),
+    /** Receiver path; defaults to `/webhook` when omitted. */
+    path: z20.string().min(1).optional()
+  }).strict(),
+  z20.object({
+    kind: z20.literal("cli"),
+    id: MockServiceIdSchema,
+    description: z20.string().min(1),
+    /** Fake-CLI shim seeded as a workspace file (today's dry-run pattern). */
+    shim: z20.object({ path: z20.string().min(1), content: z20.string() }).strict()
+  }).strict(),
+  z20.object({
+    kind: z20.literal("mcp"),
+    id: MockServiceIdSchema,
+    description: z20.string().min(1),
+    /** Override the local-catalog id when the mock replaces a real dependency. */
+    toolsetId: MockToolsetIdSchema.optional(),
+    /**
+     * Served live by the eval mock rail: each declared tool becomes a
+     * real tool on a per-trial Streamable-HTTP MCP endpoint, installed
+     * into the trial via a local-catalog `mock-mcp-<id>` toolset.
+     * `resultTemplate` is JSON-encoded as the tool result text
+     * (default `{"ok":true}` when absent).
+     */
+    tools: z20.array(
+      z20.object({
+        name: z20.string().min(1),
+        description: z20.string().min(1),
+        resultTemplate: z20.unknown().optional(),
+        /** Deterministic stateful responses, consumed in call order; the last repeats. */
+        resultSequence: z20.array(z20.unknown()).min(1).optional(),
+        /**
+         * Deterministic eval-only file materialization after this
+         * tool call. The fixture must match the container the
+         * deliverable's extension claims — a `minimal-pptx` written
+         * to a `.docx` path now fails the `binaryDocument` check on
+         * content type rather than sliding through a byte floor.
+         */
+        writeFixture: z20.object({
+          surface: z20.enum(["workspace", "artifact"]),
+          pathArgument: z20.string().min(1),
+          fixture: z20.enum(["minimal-pptx", "minimal-docx", "minimal-pdf", "minimal-png"])
+        }).strict().optional()
+      }).strict()
+    ).min(1)
+  }).strict()
+]);
+var CraftbookTestFixtureFileSchema = z20.object({
+  path: z20.string().min(1),
+  content: z20.string(),
+  /** Defaults to `workspace`; `harness` never enters the model-visible project. */
+  surface: z20.enum(["workspace", "artifact", "harness"]).optional(),
   /**
-   * Advanced exact-origin bindings for toolset credentials. Built-in provider
-   * credentials are service-pinned and webhook credentials follow the
-   * configured webhook URL, so entries for those names are ignored.
+   * Whether the fixture is presented to the model as source material.
+   * Defaults to true; false still seeds the file for browsers and graders.
    */
-  credentialAllowedOrigins: z21.record(z21.string(), z21.array(HttpsOriginSchema)).optional(),
+  modelInput: z20.boolean().optional()
+}).strict();
+var CraftbookTestWorkerSchema = z20.object({
+  name: z20.string().min(1),
+  role: z20.string().min(1),
+  description: z20.string().optional(),
+  about: z20.string().optional()
+}).strict();
+var CraftbookTestSetupSchema = z20.object({
+  projectName: z20.string().min(1),
+  about: z20.string().optional(),
+  missionObjectives: z20.string().optional(),
+  /** Reproduce project write posture before the craftbook task starts. */
+  managedWorkspaceWritePolicy: ProjectManagedWorkspaceWritePolicySchema.optional(),
+  files: z20.array(CraftbookTestFixtureFileSchema).default([]),
+  /** Exact values supplied to the catalog craftbook's `paramSchema`. */
+  craftbookParams: z20.record(z20.string(), z20.string()).optional(),
   /**
-   * Explicit user override of the project's type (an id from the bundled
-   * project-type taxonomy, see `project-types/taxonomy.ts`). When set, it
-   * wins over `detectedProjectType` for craftbook suggestions. Cleared
-   * (unset) → fall back to auto-detection. Missing on every project written
-   * before this field existed.
+   * Direct execution target. When present the harness seeds this gezel
+   * and sends the kickoff straight to it (measuring whether the book
+   * guides the work); absent → the Meester routes.
    */
-  projectTypeId: z21.string().optional(),
+  worker: CraftbookTestWorkerSchema.optional()
+}).strict();
+var CraftbookTestDeliverableSchema = z20.object({
+  path: z20.string().min(1),
+  kind: DeliverableKindSchema,
+  /** Grade the path in the project's artifacts drawer, not its workspace. */
+  artifact: z20.boolean().optional(),
+  minBytes: z20.number().int().positive().optional(),
+  checks: z20.array(CraftbookTestCheckSchema).optional()
+}).strict();
+var CraftbookTestMockExpectationSchema = z20.object({
+  /** Mock service id from `mocks[]`. */
+  service: MockServiceIdSchema,
+  minRequests: z20.number().int().positive().optional(),
+  /** Regex sources matched against logged request paths. */
+  requiredPaths: z20.array(z20.string().min(1)).optional(),
+  forbiddenPaths: z20.array(z20.string().min(1)).optional(),
   /**
-   * Auto-detected project type, recomputed on each content-index scan from
-   * the workspace file mix + about/mission text. Not user-editable — the
-   * user expresses an override via `projectTypeId`. Absent until the first
-   * scan classifies the project (or when nothing scores above the floor).
+   * Exact MCP tool names that must each have been called at least once
+   * on this service (`kind: 'mcp'` only). Exact names, not regexes —
+   * the tool roster is fully declared in the same file, so a pattern
+   * buys nothing and invites drift. Cross-checked against the mock's
+   * declared `tools[]` at parse time.
    */
-  detectedProjectType: z21.object({
-    id: z21.string(),
-    score: z21.number(),
-    scannedAt: z21.string()
-  }).optional(),
+  requiredTools: z20.array(z20.string().min(1)).optional(),
+  /** Per-MCP-tool call budgets for repeated journeys or retries. */
+  toolCalls: z20.record(
+    z20.string().min(1),
+    z20.object({
+      minCalls: z20.number().int().nonnegative().default(1),
+      maxCalls: z20.number().int().nonnegative().optional()
+    }).strict().refine(
+      (value) => value.maxCalls === void 0 || value.minCalls <= value.maxCalls,
+      "minCalls must be less than or equal to maxCalls"
+    )
+  ).optional()
+}).strict();
+var CraftbookTestHistoryExpectationSchema = z20.object({
+  kind: HistoryEventKindSchema,
+  minEntries: z20.number().int().nonnegative().default(1),
+  maxEntries: z20.number().int().nonnegative().optional(),
+  summaryPattern: z20.string().min(1).optional(),
+  flags: z20.string().optional(),
+  details: z20.record(z20.string(), z20.union([z20.string(), z20.number(), z20.boolean(), z20.null()])).optional()
+}).strict();
+var CraftbookTestSuccessSchema = z20.object({
+  summary: z20.string().min(1),
+  deliverables: z20.array(CraftbookTestDeliverableSchema).optional(),
+  checks: z20.array(CraftbookTestCheckSchema).optional(),
+  taskNotes: z20.object({
+    minBytes: z20.number().int().positive().optional(),
+    checks: z20.array(CraftbookTestCheckSchema).optional(),
+    requireCraftbookTask: z20.boolean().optional()
+  }).strict().optional(),
+  taskGraph: z20.object({
+    checks: z20.array(CraftbookTestCheckSchema).optional(),
+    requireCraftbookTask: z20.boolean().optional(),
+    /** Require the matching task to reach a terminal step (or complete). */
+    requireTerminalStep: z20.boolean().optional(),
+    requireDraftRef: z20.boolean().optional(),
+    draft: z20.object({
+      status: z20.enum(["draft", "paused", "active", "complete", "canceled"]).optional(),
+      minDescriptionBytes: z20.number().int().positive().optional(),
+      minOutcomes: z20.number().int().positive().optional(),
+      minSteps: z20.number().int().positive().optional(),
+      requireTerminalVerification: z20.boolean().optional(),
+      requireGatedBuildSteps: z20.boolean().optional()
+    }).strict().optional()
+  }).strict().optional(),
+  /** Assertions evaluated against the live mock server's request log. */
+  mocks: z20.array(CraftbookTestMockExpectationSchema).optional(),
+  /** Assertions evaluated against the project's append-only History log. */
+  history: z20.array(CraftbookTestHistoryExpectationSchema).optional(),
+  /** Workspace fixtures whose final content must equal the seeded bytes exactly. */
+  unchangedFixtures: z20.array(z20.string().min(1)).optional()
+}).strict();
+var CraftbookTestRubricSchema = z20.object({
+  artifact: z20.object({
+    /** Workspace or artifact path the judge reads (adapter derives the basename). */
+    path: z20.string().min(1),
+    kind: z20.enum(["html", "markdown", "yaml", "typescript", "json", "text"])
+  }).strict(),
+  axes: z20.array(z20.object({ name: z20.string().min(1), description: z20.string().min(1) }).strict()).min(1),
+  contextNote: z20.string().optional()
+}).strict();
+var CraftbookTestSpecSchema = z20.object({
+  schemaVersion: z20.literal(CRAFTBOOK_TEST_SCHEMA_VERSION),
+  title: z20.string().min(1),
+  objective: z20.string().min(1),
   /**
-   * Provenance of an applied custom project type (see docs/project-types.md).
-   * Distinct from `projectTypeId`, which is the taxonomy id used for craftbook
-   * suggestion: a custom type stamps this on adoption and, when it `extends` a
-   * taxonomy id, ALSO sets `projectTypeId` so detection-based suggestion
-   * inherits. Absent on projects created without a custom type.
+   * Task-class taxonomy tags (e.g. `html-game`, `corpus`, `external`).
+   * The single declared source for harness selection and batch
+   * planning — replaces the old regex classifiers.
    */
-  projectType: ProjectTypeProvenanceSchema.optional(),
+  tags: z20.array(z20.string().min(1)).default([]),
+  /** Kickoff chat message the harness sends. Required — every book runs. */
+  prompt: z20.string().min(1),
+  setup: CraftbookTestSetupSchema,
+  mocks: z20.array(MockServiceSchema).default([]),
+  success: CraftbookTestSuccessSchema,
+  rubric: CraftbookTestRubricSchema,
+  qualityFocus: z20.array(z20.string().min(1)).default([]),
   /**
-   * Filesystem ownership boundary. Missing/`user` is ordinary per-account
-   * state. `machine-shared` is a grandfathered project mounted from the
-   * installer-managed shared root and operated on by this user's daemon.
-   * The engine broker never opens the project or receives its paths.
+   * Sanctioned escape hatch for experiments — carried opaquely, never
+   * interpreted by CI. Promote a field out of here before relying on it.
    */
-  storageScope: z21.enum(["user", "machine-shared"]).optional(),
-  createdAt: z21.string(),
-  updatedAt: z21.string()
+  extensions: z20.record(z20.string(), z20.unknown()).optional()
+}).strict().superRefine((spec, ctx) => {
+  const mockIds = new Set(spec.mocks.map((m) => m.id));
+  const mockById = new Map(spec.mocks.map((m) => [m.id, m]));
+  for (const [i, expectation] of (spec.success.mocks ?? []).entries()) {
+    if (!mockIds.has(expectation.service)) {
+      ctx.addIssue({
+        code: z20.ZodIssueCode.custom,
+        path: ["success", "mocks", i, "service"],
+        message: `success.mocks[${i}] references unknown mock service "${expectation.service}"`
+      });
+    }
+    if (expectation.requiredTools && expectation.requiredTools.length > 0) {
+      const target = mockById.get(expectation.service);
+      if (target && target.kind !== "mcp") {
+        ctx.addIssue({
+          code: z20.ZodIssueCode.custom,
+          path: ["success", "mocks", i, "requiredTools"],
+          message: `success.mocks[${i}].requiredTools requires an mcp service; "${expectation.service}" is kind "${target.kind}"`
+        });
+      } else if (target?.kind === "mcp") {
+        const declared = new Set(target.tools.map((tool) => tool.name));
+        for (const name of expectation.requiredTools) {
+          if (!declared.has(name)) {
+            ctx.addIssue({
+              code: z20.ZodIssueCode.custom,
+              path: ["success", "mocks", i, "requiredTools"],
+              message: `success.mocks[${i}].requiredTools names undeclared tool "${name}" on mcp service "${expectation.service}"`
+            });
+          }
+        }
+      }
+    }
+    if (expectation.toolCalls && Object.keys(expectation.toolCalls).length > 0) {
+      const target = mockById.get(expectation.service);
+      if (target && target.kind !== "mcp") {
+        ctx.addIssue({
+          code: z20.ZodIssueCode.custom,
+          path: ["success", "mocks", i, "toolCalls"],
+          message: `success.mocks[${i}].toolCalls requires an mcp service; "${expectation.service}" is kind "${target.kind}"`
+        });
+      } else if (target?.kind === "mcp") {
+        const declared = new Set(target.tools.map((tool) => tool.name));
+        for (const name of Object.keys(expectation.toolCalls)) {
+          if (!declared.has(name)) {
+            ctx.addIssue({
+              code: z20.ZodIssueCode.custom,
+              path: ["success", "mocks", i, "toolCalls", name],
+              message: `success.mocks[${i}].toolCalls names undeclared tool "${name}" on mcp service "${expectation.service}"`
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const [i, mock] of spec.mocks.entries()) {
+    if (mock.kind === "http" && mock.credential.name !== `mock.${mock.id}`) {
+      ctx.addIssue({
+        code: z20.ZodIssueCode.custom,
+        path: ["mocks", i, "credential", "name"],
+        message: `http mock "${mock.id}" must use credential name "mock.${mock.id}"`
+      });
+    }
+  }
+  const workspaceFixtures = new Set(
+    spec.setup.files.filter((file) => file.surface === void 0 || file.surface === "workspace").map((file) => file.path)
+  );
+  for (const [i, path] of (spec.success.unchangedFixtures ?? []).entries()) {
+    if (!workspaceFixtures.has(path)) {
+      ctx.addIssue({
+        code: z20.ZodIssueCode.custom,
+        path: ["success", "unchangedFixtures", i],
+        message: `unchanged fixture "${path}" is not a seeded workspace file`
+      });
+    }
+  }
+  for (const [i, expectation] of (spec.success.history ?? []).entries()) {
+    if (expectation.maxEntries !== void 0 && expectation.minEntries > expectation.maxEntries) {
+      ctx.addIssue({
+        code: z20.ZodIssueCode.custom,
+        path: ["success", "history", i],
+        message: "minEntries must be less than or equal to maxEntries"
+      });
+    }
+  }
 });
-function resolveProjectTypeId(project) {
-  return project.projectTypeId ?? project.detectedProjectType?.id;
+function parseCraftbookTestSpec(raw, opts) {
+  const mode = opts?.mode ?? "strict";
+  const candidate = mode === "tolerant" ? deepStripUnknown(raw) : raw;
+  const parsed = CraftbookTestSpecSchema.safeParse(candidate);
+  if (parsed.success) return { ok: true, spec: parsed.data };
+  return {
+    ok: false,
+    errors: parsed.error.issues.map((issue) => {
+      const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "<root>";
+      return `${path}: ${issue.message}`;
+    })
+  };
 }
-function projectAllowsAmbientWork(project) {
-  const status = project.status ?? "active";
-  return status === "active";
+function deepStripUnknown(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const record = structuredClone(raw);
+  const version = record.schemaVersion;
+  if (typeof version === "number" && Number.isInteger(version) && version > CRAFTBOOK_TEST_SCHEMA_VERSION) {
+    record.schemaVersion = CRAFTBOOK_TEST_SCHEMA_VERSION;
+  }
+  for (let pass = 0; pass < 16; pass++) {
+    const attempt = CraftbookTestSpecSchema.safeParse(record);
+    if (attempt.success) return record;
+    const unknownKeyIssues = attempt.error.issues.filter(
+      (issue) => issue.code === z20.ZodIssueCode.unrecognized_keys
+    );
+    if (unknownKeyIssues.length === 0) return record;
+    for (const issue of unknownKeyIssues) {
+      const target = resolvePath(record, issue.path);
+      if (target && typeof target === "object" && !Array.isArray(target)) {
+        for (const key of issue.keys) delete target[key];
+      }
+    }
+  }
+  return record;
+}
+function resolvePath(root, path) {
+  let node = root;
+  for (const segment of path) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[segment];
+  }
+  return node;
 }
-var InstalledPackageSchema = z21.object({
-  name: z21.string(),
-  version: z21.string()
+
+// src/schemas/codex-setup.ts
+import { z as z21 } from "zod";
+var CodexSetupModelOptionSchema = z21.object({
+  id: z21.string().min(1),
+  label: z21.string().min(1),
+  description: z21.string().optional(),
+  kind: z21.enum(["gezel", "model"]).default("model"),
+  provider: z21.string().min(1),
+  /** Stable gezel id for persona-backed entries. Absent on raw-model entries. */
+  gezelId: z21.string().min(1).optional(),
+  role: z21.string().min(1).optional(),
+  /** Human-readable name of the effective inference model behind a gezel. */
+  modelLabel: z21.string().min(1).optional(),
+  contextWindow: z21.number().int().positive().optional(),
+  supportsReasoning: z21.boolean().optional(),
+  supportsTools: z21.boolean().optional()
 });
-var ProjectDetailSchema = ProjectSchema.extend({
-  packages: z21.array(InstalledPackageSchema),
-  /** Contents of `documents/about.md` inside the project, if present. */
-  about: z21.string().optional(),
-  /** Contents of `documents/missionObjectives.md`, if present. */
-  missionObjectives: z21.string().optional()
+var CodexSetupStateSchema = z21.enum([
+  "not-configured",
+  "configured",
+  "update-needed",
+  "conflict",
+  "unavailable"
+]);
+var CodexSetupStatusResponseSchema = z21.object({
+  state: CodexSetupStateSchema,
+  models: z21.array(CodexSetupModelOptionSchema),
+  configuredModel: z21.string().optional(),
+  recommendedModel: z21.string().optional(),
+  reasons: z21.array(z21.string()),
+  message: z21.string().optional(),
+  codexInstalled: z21.boolean(),
+  codexVersion: z21.string().optional(),
+  codexPath: z21.string().optional(),
+  endpointsEnabled: z21.boolean(),
+  profileName: z21.string().min(1),
+  profilePath: z21.string().min(1),
+  launchCommand: z21.string().min(1),
+  bridge: z21.object({
+    baseUrl: z21.string().url(),
+    listening: z21.boolean(),
+    port: z21.number().int().nonnegative()
+  }),
+  canConfigure: z21.boolean(),
+  /** Whether Gezel-owned credential/state material exists and can be safely removed. */
+  canRemove: z21.boolean()
 });
-var ProjectFileEntrySchema = z21.object({
-  name: z21.string(),
-  path: z21.string(),
-  isDirectory: z21.boolean(),
-  /** File mtime (ms epoch). Populated only when the caller opts into stats. */
-  mtimeMs: z21.number().optional()
+var ConfigureCodexRequestSchema = z21.object({
+  model: z21.string().min(1)
 });
-var ProjectGithubSchema = ProjectGitHubSchema;
 
 // src/schemas/project-local.ts
 import { z as z22 } from "zod";
@@ -5169,6 +5226,15 @@ var TaskSchema = z23.object({
       issueRef: z23.string().regex(/^BW-[1-9]\d*$/),
       path: z23.string().min(1)
     }),
+    z23.object({
+      /**
+       * An invoke_craftbook call keyed to one persisted root chat turn.
+       * The HTTP task boundary uses this opaque digest to return the first
+       * still-active task when a provider continuation repeats the call.
+       */
+      kind: z23.literal("craftbook-invocation"),
+      key: z23.string().regex(/^craftbook-root-v1:[a-f0-9]{64}$/)
+    }),
     z23.object({
       /**
        * A host materialized from a gezel template's `suggestedCraftbooks`
@@ -5198,6 +5264,13 @@ var TaskSchema = z23.object({
     params: z23.record(z23.string(), z23.unknown()).optional(),
     at: z23.string()
   }).optional(),
+  /**
+   * Naming presentation inherited from the session that launched this
+   * workflow. Task handoffs create fresh sessions (and may be rehydrated
+   * after restart), so they cannot rely on the launcher's session record
+   * still being available when the next step starts.
+   */
+  roleBasedNameOnlyMode: z23.boolean().optional(),
   createdAt: z23.string(),
   updatedAt: z23.string(),
   createdBy: TaskAssigneeSchema
@@ -5252,6 +5325,8 @@ var CreateTaskRequestSchema = z23.object({
   }).optional(),
   fanout: NewTaskFanoutSchema.optional(),
   createdBy: TaskAssigneeSchema.optional(),
+  /** Preserve the launcher's naming presentation across task handoffs. */
+  roleBasedNameOnlyMode: z23.boolean().optional(),
   /**
    * Enqueue the entry-step handoff immediately after create — the
    * single-channel kickoff (there is no "tell a gezel about work"
@@ -5261,7 +5336,13 @@ var CreateTaskRequestSchema = z23.object({
    * on cron/fanout hosts (their children dispatch via their own
    * activation hooks — flag-dispatching the host would double-engage).
    */
-  dispatchEntry: z23.boolean().optional()
+  dispatchEntry: z23.boolean().optional(),
+  /**
+   * Internal invoke_craftbook idempotency digest. The task route converts
+   * it into service-owned Task.origin provenance; ordinary create_task
+   * callers omit it.
+   */
+  craftbookInvocationKey: z23.string().regex(/^craftbook-root-v1:[a-f0-9]{64}$/).optional()
 }).refine((v) => !!v.craftbookId !== !!(v.steps && v.steps.length > 0), {
   message: "exactly one of craftbookId or steps must be provided for the main craftbook",
   path: ["craftbookId"]
@@ -5365,6 +5446,8 @@ var UpdateTaskStepRequestSchema = z23.object({
   /** Step automation hooks (single ref or ordered list). `null` detaches. */
   onEnter: ScriptRefListSchema.nullable().optional(),
   onExit: ScriptRefListSchema.nullable().optional(),
+  /** Required file inputs for the step. `null` clears the declaration. */
+  consumes: z23.array(CraftbookStepInputSchema).min(1).nullable().optional(),
   /** Auto-advance contract. `null` clears it. */
   advanceWhen: AdvanceWhenSchema.nullable().optional(),
   /** The end-of-step gate (current or legacy shape). `null` clears it. */
@@ -6175,7 +6258,7 @@ var ProjectTypeCompositionShape = {
   tabVisibility: ProjectTabVisibilitySchema.optional(),
   /**
    * Project shape for instances of this type. `solo` marks a single-gezel
-   * "ambachtsman" experience (games, the chat room): the one roster gezel
+   * "Builder" experience (games, the chat room): the one roster gezel
    * does everything, no separate overseer voorman is recruited, and the UI
    * collapses the crew picker to that lead. Maps onto the project's `mode`
    * at adoption. Omit for the default crew shape.
@@ -6183,9 +6266,9 @@ var ProjectTypeCompositionShape = {
   mode: z26.enum(["crew", "solo"]).optional(),
   /**
    * Custom label for this type's project lead, shown wherever the generic
-   * "Voorman" / "Ambachtsman" would appear (the chat chip, project
+   * "Voorman" / "Builder" would appear (the chat chip, project
    * settings) — e.g. checkers uses "Opponent". Aimed at solo types that
-   * want a domain word instead of "Ambachtsman". The underlying data field
+   * want a domain word instead of "Builder". The underlying data field
    * stays `voormanGezelId`; only the rendered label changes.
    */
   leadLabel: z26.string().min(1).optional(),
@@ -6294,6 +6377,13 @@ var ConnectorActionSchema = z26.object({
   /** Consent gate this action clears at commit time (e.g. `recipient-allowlist`). */
   consentScope: z26.string()
 });
+var ConnectorSetupInstructionsSchema = z26.object({
+  title: z26.string().min(1),
+  description: z26.string().min(1).optional(),
+  steps: z26.array(z26.string().min(1)).optional(),
+  url: z26.string().url().optional(),
+  urlLabel: z26.string().min(1).optional()
+});
 var ConnectorTypeCompositionShape = {
   /** Which driver executes the fetch. */
   driver: ConnectorDriverSchema,
@@ -6301,6 +6391,8 @@ var ConnectorTypeCompositionShape = {
   configSchema: z26.record(z26.string(), z26.unknown()).optional(),
   /** Shape of the credential the binding stores in the SecretStore. */
   secretShape: z26.record(z26.string(), z26.unknown()).optional(),
+  /** Concise setup guidance rendered above the binding form. */
+  setupInstructions: ConnectorSetupInstructionsSchema.optional(),
   /**
    * Driver-specific fetch config: `{adapterId}` (native) | `{server,list,fetch}`
    * (mcp) | `{fetch|cli}` (script) | `{component,action,...}` (spectral).
@@ -6610,6 +6702,15 @@ var ChatModelMlxSourceSchema = z26.object({
 });
 var ChatModelIdentitySchema = IdentityCommonSchema.extend({
   kind: z26.literal("chat-model"),
+  /**
+   * Organization that created the core model weights when it differs from
+   * the catalog maintainer (for example, a quant maintained by its converter).
+   * Omit when `maintainer` already names the maker.
+   */
+  maker: z26.object({
+    name: z26.string().min(1),
+    url: z26.string().url().optional()
+  }).optional(),
   parameterSize: z26.string(),
   supportsTools: z26.boolean(),
   contextWindow: z26.number().int().positive().optional(),
@@ -6707,6 +6808,11 @@ var ChatModelManifestSchema = z26.object({
     name: z26.string(),
     url: z26.string().url().optional()
   }),
+  /** Core-model maker; present when it differs from `maintainer`. */
+  maker: z26.object({
+    name: z26.string().min(1),
+    url: z26.string().url().optional()
+  }).optional(),
   logo: z26.string().optional(),
   license: z26.string().optional(),
   ...LicenseMetaShape,
@@ -7518,6 +7624,18 @@ var ChatSessionSchema = z28.object({
   }),
   /** Snapshot of the gezel's about.md at session creation, for drift warnings. */
   aboutSnapshot: z28.string().optional(),
+  /**
+   * Per-session override of `config.roleBasedNameOnlyMode` ("boring mode").
+   * Stamped at creation when the creating client has a fixed presentation
+   * mode — the TUI always renders role-based labels, so it pins the
+   * sessions it creates to `true`. This keeps the prompt (what the model
+   * is told about other gezels) consistent with what that client shows;
+   * without it the TUI displayed `reviewer:` while the system prompt said
+   * "the voorman is Tomas", and the model naturally leaked names into
+   * prose. Unset = follow the live config flag, which is what desktop
+   * sessions do.
+   */
+  roleBasedNameOnlyMode: z28.boolean().optional(),
   /** Set when the last attempted resume failed — UI surfaces a banner. */
   resumeFailed: z28.boolean().optional(),
   /**
@@ -7746,7 +7864,14 @@ var CreateChatSessionRequestSchema = z28.object({
   projectId: z28.string().optional(),
   taskRef: z28.string().optional(),
   stepId: z28.string().optional(),
-  craftbookRef: z28.string().optional()
+  craftbookRef: z28.string().optional(),
+  /**
+   * Pin the session's name-rendering mode instead of following
+   * `config.roleBasedNameOnlyMode`. Passed by clients whose presentation
+   * mode is fixed (the TUI) so prompt-side name rendering matches their
+   * labels. See `ChatSessionSchema.roleBasedNameOnlyMode`.
+   */
+  roleBasedNameOnlyMode: z28.boolean().optional()
 });
 var ListChatSessionsResponseSchema = z28.object({
   sessions: z28.array(ChatSessionSummarySchema)
@@ -8372,13 +8497,26 @@ var GitHubPullFileSchema = z33.object({
   additions: z33.number().int(),
   deletions: z33.number().int(),
   changes: z33.number().int(),
-  /** Truncated unified diff hunk, if returned by GitHub. */
+  /** Unified diff hunk, if requested and returned by GitHub. */
   patch: z33.string().optional(),
+  /** Character count before Gezel's local patch budget was applied. */
+  patchChars: z33.number().int().nonnegative().optional(),
+  /** True when Gezel clipped `patch`; callers must request the file/diff directly. */
+  patchTruncated: z33.boolean().optional(),
   /** Prior path when `status === 'renamed'`. */
   previousFilename: z33.string().optional()
 });
 var ListGitHubPullFilesResponseSchema = z33.object({
-  files: z33.array(GitHubPullFileSchema)
+  files: z33.array(GitHubPullFileSchema),
+  /** Total files in the PR before an optional path filter. */
+  allFiles: z33.number().int().nonnegative().optional(),
+  /** Total files selected by the optional path filter. */
+  totalFiles: z33.number().int().nonnegative().optional(),
+  offset: z33.number().int().nonnegative().optional(),
+  limit: z33.number().int().positive().optional(),
+  hasMore: z33.boolean().optional(),
+  nextOffset: z33.number().int().nonnegative().optional(),
+  includesPatch: z33.boolean().optional()
 });
 var GitHubPullCommentSchema = z33.object({
   id: z33.number(),
@@ -8395,7 +8533,14 @@ var ListGitHubPullCommentsResponseSchema = z33.object({
 });
 var GitHubPullDiffResponseSchema = z33.object({
   number: z33.number().int(),
-  diff: z33.string()
+  diff: z33.string(),
+  /** Exact changed path when this is a file-scoped diff. */
+  path: z33.string().optional(),
+  offset: z33.number().int().nonnegative().optional(),
+  returnedChars: z33.number().int().nonnegative().optional(),
+  totalChars: z33.number().int().nonnegative().optional(),
+  truncated: z33.boolean().optional(),
+  nextOffset: z33.number().int().nonnegative().optional()
 });
 var GitHubCreateCommentRequestSchema = z33.object({
   body: z33.string().min(1)
@@ -10683,6 +10828,13 @@ var GezelConfigSchema = z37.object({
    * Advanced.
    */
   showAdvancedFeatures: z37.boolean().optional(),
+  /**
+   * When `true`, very early work-in-progress surfaces are revealed in the
+   * UI and CLI. This is a discoverability preference, not a security or
+   * service-layer capability boundary. Defaults on in development builds
+   * and off in releases; an explicit user choice always wins.
+   */
+  showWorkInProgressFeatures: z37.boolean().optional(),
   /**
    * Debug-only opt-in: when `true`, the service rewrites every
    * template-derived gezel's `about.md` back to the prose its catalog
@@ -10959,7 +11111,7 @@ var GezelConfigSchema = z37.object({
    *    crew with granular per-step craftbooks. Right for raw-completion
    *    local models, where gezel's loop IS the agent.
    *  - `flat`: route concrete asks to a single generalist (`start_job` →
-   *    solo "ambachtsman", which already collapses the craftbook onto the
+   *    solo Builder, which already collapses the craftbook onto the
    *    one specialist). Right for self-orchestrating providers (codex-cli,
    *    anthropic-cli, copilot) that bring their own agent loop — the crew
    *    + granular steps are mostly redundant overhead for them (eval data:
@@ -11863,6 +12015,12 @@ var ListProjectsResponseSchema = z37.object({
 var CreateProjectRequestSchema = z37.object({
   name: z37.string().min(1),
   description: z37.string().optional(),
+  /**
+   * Existing local folder to use as the project workspace. Folder-backed
+   * projects are created with ambient Meester progress check-ins disabled;
+   * the user can opt back in from Project Settings.
+   */
+  workingDir: z37.string().min(1).optional(),
   // about/missionObjectives are *encouraged, not required* at the wire level.
   // The New Project dialog still enforces the 60/40 richness minimums for the
   // blank/GitHub flows (where the user is authoring context from scratch), but
@@ -11875,7 +12033,7 @@ var CreateProjectRequestSchema = z37.object({
   missionObjectives: z37.string().optional().describe('Concrete success criteria \u2014 usually a bullet list. What does "done" look like?'),
   /**
    * Project shape. `crew` (default) → traditional voorman-coordinates-
-   * specialists. `solo` → a "job": one specialist (the ambachtsman) does
+   * specialists. `solo` → a "job": one Builder does
    * everything themselves; team-management tools are filtered out for
    * sessions on this project.
    */
@@ -15039,6 +15197,7 @@ export {
   CraftbookSchema,
   CraftbookScriptsSchema,
   CraftbookSpawnSchema,
+  CraftbookStepInputSchema,
   CraftbookStepSchema,
   CraftbookSuggestionSchema,
   CraftbookSummarySchema,