@bendyline/gezel 1.0.2 → 1.0.3

package/dist/index.js

@@ -500,13 +500,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
@@ -649,6 +650,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
@@ -921,6 +936,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),
@@ -961,6 +982,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). */
@@ -1015,6 +1040,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") {
@@ -1307,6 +1340,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. */
@@ -1419,6 +1455,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 } : {},
@@ -1541,6 +1578,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;
@@ -1719,7 +1760,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";
@@ -3701,7 +3742,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
@@ -4242,444 +4291,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);
@@ -4690,7 +4304,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.
@@ -4698,89 +4312,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
    *  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
@@ -4790,7 +4404,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
@@ -4805,7 +4419,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
@@ -4815,7 +4429,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`,
@@ -4824,7 +4438,7 @@ 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
@@ -4835,7 +4449,7 @@ var ProjectSchema = z21.object({
    * 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
@@ -4843,7 +4457,7 @@ var ProjectSchema = z21.object({
    * "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
@@ -4851,7 +4465,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
@@ -4864,9 +4478,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(),
   /**
@@ -4889,7 +4503,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
@@ -4926,7 +4540,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
@@ -4936,13 +4550,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
@@ -4951,76 +4565,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";
@@ -5532,6 +5585,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. */
@@ -6461,6 +6516,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,
@@ -6468,6 +6530,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).
@@ -6777,6 +6841,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(),
@@ -6874,6 +6947,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,
@@ -7685,6 +7763,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(),
   /**
@@ -7913,7 +8003,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)
@@ -8539,13 +8636,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(),
@@ -8562,7 +8672,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)
@@ -10850,6 +10967,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
@@ -17460,6 +17584,7 @@ var STEP_FENCE_KEYS = [
   "deliverable",
   "onEnter",
   "onExit",
+  "consumes",
   "advanceWhen",
   "gate",
   "next",
@@ -18757,6 +18882,68 @@ function isMoEFromTags(tags) {
   });
 }
 
+// src/model-attribution.ts
+function modelAttribution(manifest) {
+  const sourceOwners = [
+    manifest.llamaCpp?.huggingfaceRepo,
+    manifest.mlx?.huggingfaceRepo,
+    manifest.ds4?.huggingfaceRepo
+  ].map((repo) => repo ? huggingFaceOwnerFromRepo(repo) : null).filter((owner) => owner !== null);
+  const explicitMakerOwner = manifest.maker?.url ? huggingFaceOwnerFromUrl(manifest.maker.url) : null;
+  const maintainerOwner = manifest.maintainer.url ? huggingFaceOwnerFromUrl(manifest.maintainer.url) : null;
+  const upstreamOwner = manifest.upstream ? huggingFaceOwnerFromUrl(manifest.upstream) : null;
+  const normalizedSources = new Set(sourceOwners.map(normalizeOrganization));
+  const maintainerIsSource = [manifest.maintainer.name, maintainerOwner].filter((name) => name !== null).some((name) => normalizedSources.has(normalizeOrganization(name)));
+  const upstreamIsSource = upstreamOwner ? normalizedSources.has(normalizeOrganization(upstreamOwner)) : false;
+  const makerFromUpstream = !manifest.maker && maintainerIsSource && upstreamOwner && !upstreamIsSource;
+  const maker = manifest.maker?.name ?? (makerFromUpstream ? displayOrganizationName(upstreamOwner) : manifest.maintainer.name);
+  const makerAliases = /* @__PURE__ */ new Set([normalizeOrganization(maker)]);
+  if (explicitMakerOwner) makerAliases.add(normalizeOrganization(explicitMakerOwner));
+  if (upstreamOwner) makerAliases.add(normalizeOrganization(upstreamOwner));
+  if (!manifest.maker && !makerFromUpstream) {
+    makerAliases.add(normalizeOrganization(manifest.maintainer.name));
+    if (maintainerOwner) makerAliases.add(normalizeOrganization(maintainerOwner));
+  }
+  const customizers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const customizerCandidates = manifest.maker ? [manifest.maintainer.name, ...sourceOwners] : sourceOwners;
+  for (const owner of customizerCandidates) {
+    const normalized = normalizeOrganization(owner);
+    if (!normalized || makerAliases.has(normalized) || seen.has(normalized)) continue;
+    seen.add(normalized);
+    customizers.push(owner);
+  }
+  return { maker, customizers };
+}
+function displayOrganizationName(owner) {
+  const knownNames = {
+    "deepseek-ai": "DeepSeek",
+    "zai-org": "Z.ai"
+  };
+  return knownNames[owner.toLowerCase()] ?? owner;
+}
+function formatModelAttribution(manifest) {
+  const attribution = modelAttribution(manifest);
+  return attribution.customizers.length > 0 ? `${attribution.maker}, customized by ${attribution.customizers.join(", ")}` : attribution.maker;
+}
+function huggingFaceOwnerFromRepo(repo) {
+  const slash = repo.indexOf("/");
+  return slash > 0 ? repo.slice(0, slash) : null;
+}
+function huggingFaceOwnerFromUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.hostname.toLowerCase() !== "huggingface.co") return null;
+    const owner = url.pathname.split("/").filter(Boolean)[0];
+    return owner ?? null;
+  } catch {
+    return null;
+  }
+}
+function normalizeOrganization(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
 // src/fitness-badge.ts
 var CHECK_LABELS = [
   { key: "spawn", label: "did not start" },
@@ -25379,6 +25566,11 @@ function collapseCraftbookForTier(book, opts) {
       0,
       ...members.map((m) => m.gate ? normalizeStepGate(m.gate).maxAttempts ?? 0 : 0)
     );
+    const consumes = members.flatMap((member) => member.consumes ?? []).filter(
+      (input, index, all) => all.findIndex(
+        (candidate) => candidate.file === input.file && Boolean(candidate.artifact) === Boolean(input.artifact)
+      ) === index
+    );
     const isLast = groupIdx === groups.length - 1;
     const nextGroupAnchor = groups[groupIdx + 1];
     const nextId = nextGroupAnchor ? nextGroupAnchor.filter((m) => hasCompletionGate(m)).slice(-1)[0] ?? nextGroupAnchor[nextGroupAnchor.length - 1] : void 0;
@@ -25394,6 +25586,7 @@ function collapseCraftbookForTier(book, opts) {
     const step = {
       ...anchor,
       prompt: collapsedPrompt({ anchor, mergedNames, checks }),
+      ...consumes.length > 0 ? { consumes } : { consumes: void 0 },
       gate,
       // Terminal + advanceWhen is an illegal combination; the terminal
       // group keeps only its completion gate.
@@ -25403,7 +25596,7 @@ function collapseCraftbookForTier(book, opts) {
         advanceWhen: anchor.advanceWhen ? { ...anchor.advanceWhen, goto: void 0 } : void 0
       }
     };
-    for (const key of ["terminal", "advanceWhen", "next"]) {
+    for (const key of ["terminal", "advanceWhen", "next", "consumes"]) {
       if (step[key] === void 0) delete step[key];
     }
     if (step.advanceWhen && step.advanceWhen.goto === void 0) {
@@ -25542,6 +25735,16 @@ function docFromCraftbook(book) {
   };
 }
 function augmentGraphProblem(problem, stepIds) {
+  const artifactInput = /^step "([^"]+)" consumes artifact "([^"]+)" but its prompt does not explicitly call `read_artifact`$/.exec(
+    problem
+  );
+  if (artifactInput) {
+    return {
+      where: `steps (id "${artifactInput[1]}") \u2192 prompt`,
+      message: `${problem}.`,
+      fix: `start the procedure with \`read_artifact({ path: ${JSON.stringify(artifactInput[2])} })\`; artifact paths are not workspace paths`
+    };
+  }
   const missing = /"([^"]+)" missing from steps/.exec(problem);
   if (missing) {
     const near = nearestMatch(missing[1], stepIds);
@@ -26861,9 +27064,38 @@ function deriveThreadTitleFromMessages(messages, options = {}) {
   return starter ? deriveThreadTitle(starter.content) : null;
 }
 
+// src/catalog-work-in-progress.ts
+var CONNECTOR_PROJECT_TYPE_BASES = /* @__PURE__ */ new Set(["email", "social-media"]);
+function resolveShowWorkInProgressFeatures(configured, buildVersion) {
+  return configured ?? buildVersion === "0.0.0";
+}
+function catalogItemUsesConnectors(item, connectorCraftbookIds2 = /* @__PURE__ */ new Set()) {
+  const manifest = item.manifest;
+  if (manifest.kind === "craftbook-template") {
+    return (manifest.connectors?.length ?? 0) > 0;
+  }
+  if (manifest.kind !== "project-type") return false;
+  if (manifest.extends && CONNECTOR_PROJECT_TYPE_BASES.has(manifest.extends)) return true;
+  if ((manifest.craftbooks ?? []).some((id) => connectorCraftbookIds2.has(id))) return true;
+  return (manifest.schedules ?? []).some(
+    (schedule) => connectorCraftbookIds2.has(schedule.craftbook)
+  );
+}
+function connectorCraftbookIds(items) {
+  return new Set(
+    items.flatMap(
+      (item) => item.manifest.kind === "craftbook-template" && catalogItemUsesConnectors(item) ? [item.manifest.id] : []
+    )
+  );
+}
+function visibleCatalogItems(items, showWorkInProgressFeatures, connectorIds = connectorCraftbookIds(items)) {
+  if (showWorkInProgressFeatures) return [...items];
+  return items.filter((item) => !catalogItemUsesConnectors(item, connectorIds));
+}
+
 // src/index.ts
-var GEZEL_VERSION = "1.0.2";
-var GEZEL_CONTENT_COMPAT = "1.26225";
+var GEZEL_VERSION = "1.0.3";
+var GEZEL_CONTENT_COMPAT = "1.26226";
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -26990,6 +27222,7 @@ export {
   CraftbookSchema,
   CraftbookScriptsSchema,
   CraftbookSpawnSchema,
+  CraftbookStepInputSchema,
   CraftbookStepSchema,
   CraftbookSuggestionSchema,
   CraftbookSummarySchema,
@@ -27895,6 +28128,7 @@ export {
   blockSize,
   buildIssueUrl,
   buildSuiteScoreboard,
+  catalogItemUsesConnectors,
   cellAttributableTrials,
   classifySecurityLevel,
   coerceDeliverableKind,
@@ -27906,6 +28140,7 @@ export {
   composeFileContext,
   composeFitnessBadge,
   computeModelFit,
+  connectorCraftbookIds,
   craftbookDocFormatFromEnv,
   craftbookFromDoc,
   craftbookRequirementsMet,
@@ -27948,6 +28183,7 @@ export {
   formatCraftbookDocErrors,
   formatErrorReport,
   formatJsonSchemaViolations,
+  formatModelAttribution,
   formatNpmRegistrySpec,
   formatPassClaim,
   formatReviewProvenance,
@@ -28024,6 +28260,7 @@ export {
   meetsCapabilityFloor,
   mergeStreets,
   metaToFormValue,
+  modelAttribution,
   modelFitnessKey,
   nearestFreeRect,
   nearestMatch,
@@ -28098,6 +28335,7 @@ export {
   resolveRoleId,
   resolveSandboxCopilot,
   resolveSecurityPolicy,
+  resolveShowWorkInProgressFeatures,
   resolveSteps,
   retryTransient,
   rewriteGezelHrefs,
@@ -28154,6 +28392,7 @@ export {
   validateScriptInput,
   verifyBinaryDocumentBytes,
   videoMemoryBudgetBytes,
+  visibleCatalogItems,
   workshopTempoDefaults,
   writeProcessOutput,
   xpForLevel,