@productbrain/mcp 0.0.1-beta.3346 → 0.0.1-beta.3359

package/dist/{chunk-252CQV5P.js → chunk-KTRECBYJ.js}

@@ -46,7 +46,7 @@ import {
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/tools/entries.ts
-import { z as z6 } from "zod/v3";
+import { z as z8 } from "zod/v3";
 
 // src/envelope.ts
 import { z } from "zod/v3";
@@ -540,10 +540,10 @@ async function dispatchDiscriminated(toolName, union2, flatData, actionSpecs, ha
 }
 
 // src/tools/knowledge.ts
-import { z as z3 } from "zod/v3";
+import { z as z5 } from "zod/v3";
 
 // src/tools/smart-capture.ts
-import { z as z2 } from "zod/v3";
+import { z as z4 } from "zod/v3";
 
 // src/lib/scopedCache.ts
 var ScopedCache = class {
@@ -637,115 +637,809 @@ function coherencyRefusedResult(toolName, entryId, refusal, options) {
     if (lines.length === beforeRoutes) {
       lines.push(GENERIC_RECOVERY_LINE);
     }
-  } else {
-    lines.push("", GENERIC_RECOVERY_LINE);
+  } else {
+    lines.push("", GENERIC_RECOVERY_LINE);
+  }
+  return failureResult(
+    lines.join("\n"),
+    "COHERENCY_REFUSED",
+    `Coherency gate refused ${toolName} on ${entryId}.`,
+    "Use one of the refusal's routes (link / coherencyAcknowledgement / steeringOverrideReason), then retry.",
+    void 0,
+    { entryId, refusal }
+  );
+}
+
+// src/lib/resolveCollection.ts
+async function resolveCollection(params) {
+  const { name, description, typeHint, allowReviewRouting } = params;
+  const sessionId = getAgentSessionId();
+  const result2 = await kernelCall("chain.resolveCollection", {
+    entryName: name,
+    entryDescription: description,
+    ...typeHint ? { typeHint } : {},
+    ...allowReviewRouting ? { allowReviewRouting } : {},
+    ...sessionId ? { agentSessionId: sessionId } : {}
+  });
+  return result2 ?? null;
+}
+
+// src/lib/fieldTypes.ts
+var FIELD_TYPE_DEFAULTS = {
+  "string": "",
+  "text": "",
+  "rich-text": "",
+  "number": null,
+  "boolean": false,
+  "select": null,
+  "multi-select": [],
+  "array": [],
+  "json": null,
+  "date": null,
+  "person": null
+};
+
+// src/lib/formatFieldGuidance.ts
+function formatFieldGuidance(fields) {
+  const guidedFields = fields.filter((f) => f.writingGuidance);
+  if (guidedFields.length === 0) return "";
+  const lines = ["## Writing Guidance"];
+  for (const field of guidedFields) {
+    const displayName = field.label || field.key;
+    lines.push(`- ${displayName}: ${field.writingGuidance}`);
+    if (field.writingExamples && field.writingExamples.length > 0) {
+      lines.push(`  Examples: ${field.writingExamples.join(" | ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/lib/inferSourceDate.ts
+function inferSourceDate(...values) {
+  const combined = values.filter((value) => typeof value === "string" && value.trim().length > 0).join("\n");
+  if (!combined) return void 0;
+  const isoMatch = combined.match(/\b(20\d{2}-\d{2}-\d{2})\b/);
+  if (isoMatch) return isoMatch[1];
+  const monthMatch = combined.match(
+    /\b(january|february|march|april|may|june|july|august|september|october|november|december)\s+(\d{1,2})(?:st|nd|rd|th)?(?:,?\s+(20\d{2}))?\b/i
+  );
+  if (!monthMatch) return void 0;
+  const monthIndex = [
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december"
+  ].indexOf(monthMatch[1].toLowerCase());
+  if (monthIndex < 0) return void 0;
+  const inferredYear = monthMatch[3] ?? combined.match(/\b(20\d{2})\b/)?.[1] ?? String((/* @__PURE__ */ new Date()).getUTCFullYear());
+  const month = String(monthIndex + 1).padStart(2, "0");
+  const day = monthMatch[2].padStart(2, "0");
+  return `${inferredYear}-${month}-${day}`;
+}
+
+// src/lib/collectionCache.ts
+var collectionCache = new ScopedCache(COLLECTION_CACHE_TTL_MS);
+async function getCollections() {
+  const scope = cacheScope();
+  const hit = collectionCache.get(scope);
+  if (hit) return hit.collections;
+  const result2 = await kernelQuery("chain.listCollections") ?? [];
+  const bySlug = new Map(result2.map((c) => [c.slug, c]));
+  collectionCache.set(scope, { collections: result2, bySlug });
+  return result2;
+}
+async function getCollectionBySlug(slug) {
+  await getCollections();
+  return collectionCache.get(cacheScope())?.bySlug.get(slug);
+}
+function invalidateCollectionCacheForScope() {
+  collectionCache.delete(cacheScope());
+}
+async function isGoverned(slug) {
+  const col = await getCollectionBySlug(slug);
+  return !!col?.governed;
+}
+
+// src/lib/textMatch.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "but",
+  "not",
+  "you",
+  "all",
+  "can",
+  "has",
+  "her",
+  "was",
+  "one",
+  "our",
+  "out",
+  "day",
+  "had",
+  "hot",
+  "how",
+  "its",
+  "may",
+  "new",
+  "now",
+  "old",
+  "see",
+  "way",
+  "who",
+  "did",
+  "get",
+  "let",
+  "say",
+  "she",
+  "too",
+  "use",
+  "from",
+  "have",
+  "been",
+  "each",
+  "that",
+  "this",
+  "with",
+  "will",
+  "they",
+  "what",
+  "when",
+  "make",
+  "like",
+  "long",
+  "look",
+  "many",
+  "some",
+  "them",
+  "than",
+  "most",
+  "only",
+  "over",
+  "such",
+  "into",
+  "also",
+  "back",
+  "just",
+  "much",
+  "must",
+  "name",
+  "very",
+  "your",
+  "after",
+  "which",
+  "their",
+  "about",
+  "would",
+  "there",
+  "should",
+  "could",
+  "other",
+  "these",
+  "first",
+  "being",
+  "those",
+  "still",
+  "where"
+]);
+function tokenizeText(input) {
+  return input.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").split(/\s+/).filter(Boolean);
+}
+
+// src/lib/batchCaptureOutput.ts
+import { z as z2 } from "zod/v3";
+var batchCaptureRealOutputSchema = z2.object({
+  captured: z2.array(z2.object({
+    entryId: z2.string(),
+    collection: z2.string(),
+    name: z2.string(),
+    // "draft_on_failure" is the status emitted when an auto-commit is REFUSED/failed (the entry
+    // stays a draft) — the same path that now also emits coherencyRefusal. The strict schema must
+    // accept it or a refused response fails to validate on `status` (codex review, completing the
+    // coherencyRefusal contract fix).
+    status: z2.enum(["draft", "committed", "proposed", "draft_on_failure"]),
+    classifiedBy: z2.enum(["llm", "heuristic", "explicit"]).optional(),
+    confidence: z2.number().optional(),
+    confidenceTier: z2.enum(["high", "medium", "low"]).optional(),
+    warnings: z2.array(z2.string()).optional(),
+    normalization: z2.object({
+      remapped: z2.record(z2.string()).optional(),
+      rejected: z2.array(z2.string()).optional()
+    }).optional(),
+    // TEN-2365: capture-time authority-domain proposal slug (PENDING ratification), when filed.
+    domain: z2.string().optional(),
+    // WP-465 surface parity: structured coherency refusal for a gate-refused auto-commit (batch
+    // shape). Loose record — same single-source rationale as captureSuccessOutputSchema.
+    coherencyRefusal: z2.record(z2.unknown()).optional(),
+    // WP-485 Slice 2b round 4 (Codex P2, FEAT-1370): per-entry contradiction advisory, emitted
+    // into structuredContent but previously undeclared here. Not `.strict()` so this one was
+    // silently stripped rather than rejected — declared anyway so batch consumers actually see it.
+    contradictionAdvisory: z2.record(z2.unknown()).optional()
+  })),
+  total: z2.number(),
+  failed: z2.number(),
+  committed: z2.number(),
+  proposed: z2.number(),
+  drafts: z2.number(),
+  classified: z2.number().optional(),
+  autoCommitApplied: z2.boolean(),
+  skippedLowConfidence: z2.array(z2.object({
+    index: z2.number(),
+    name: z2.string(),
+    suggestedCollection: z2.string().optional(),
+    confidence: z2.number().optional(),
+    alternatives: z2.array(z2.object({
+      collection: z2.string(),
+      confidence: z2.number()
+    })).optional()
+  })).optional(),
+  failedEntries: z2.array(z2.object({
+    index: z2.number(),
+    collection: z2.string(),
+    name: z2.string(),
+    error: z2.string()
+  })).optional()
+});
+var batchCapturePreviewOutputSchema = z2.object({
+  outcome: z2.literal("preview"),
+  wouldCapture: z2.array(z2.object({
+    // Fix 1 (WP-577 review re-review, TEN-2918 follow-up): optional, not required — see
+    // WouldCaptureEntry's doc comment. Absent exactly when `entryIdAssignedAtCapture` is true.
+    entryId: z2.string().optional(),
+    entryIdAssignedAtCapture: z2.literal(true).optional(),
+    collection: z2.string(),
+    name: z2.string(),
+    classifiedBy: z2.string().optional(),
+    confidence: z2.number().optional(),
+    warnings: z2.array(z2.string()).optional()
+  })),
+  // WP-577 review follow-up (P2, TEN-2918): entries the server's WHY/glossary gate says would
+  // be BLOCKED on a real (non-preview) create — a distinct cohort from `wouldCapture` so the
+  // structured response never claims a governance-refused capture would succeed. Optional/
+  // additive: absent (or empty) on every response this route produced before this fix.
+  wouldBlock: z2.array(z2.object({
+    entryId: z2.string().optional(),
+    entryIdAssignedAtCapture: z2.literal(true).optional(),
+    collection: z2.string(),
+    name: z2.string(),
+    blockingReason: z2.string().optional(),
+    warnings: z2.array(z2.string()).optional()
+  })).optional(),
+  requested: z2.number(),
+  total: z2.number(),
+  failed: z2.number(),
+  skippedLowConfidence: z2.array(z2.object({
+    index: z2.number(),
+    name: z2.string(),
+    suggestedCollection: z2.string().optional(),
+    confidence: z2.number().optional()
+  })).optional(),
+  failedEntries: z2.array(z2.object({
+    index: z2.number(),
+    collection: z2.string(),
+    name: z2.string(),
+    error: z2.string()
+  })).optional()
+});
+var batchCaptureOutputSchema = z2.union([
+  batchCaptureRealOutputSchema,
+  batchCapturePreviewOutputSchema
+]);
+function buildBatchPreviewSummary({ wouldCapture, wouldBlock = [], failed, skipped, requested }) {
+  const noun = requested === 1 ? "entry" : "entries";
+  const blockedNote = wouldBlock.length > 0 ? `, ${wouldBlock.length} would be BLOCKED` : "";
+  const failedNote = failed.length > 0 ? `, ${failed.length} would fail` : "";
+  const skippedNote = skipped.length > 0 ? `, ${skipped.length} skipped (low confidence)` : "";
+  return `Preview: would capture ${wouldCapture.length} of ${requested} ${noun}${blockedNote}${failedNote}${skippedNote} \u2014 no DB writes.`;
+}
+function buildBatchEntryFailure(args) {
+  return {
+    entryIdx: args.entryIdx,
+    name: args.name,
+    collection: args.collection,
+    entryId: "",
+    ok: false,
+    autoLinks: 0,
+    advisedLinks: 0,
+    status: "draft",
+    classifiedBy: args.classifiedBy,
+    confidence: args.confidence,
+    confidenceTier: args.confidenceTier,
+    error: args.error
+  };
+}
+function buildBatchPreviewFromResults(created, failed, skipped, requested, originalItems, originalAutoCommit) {
+  const wouldCaptureEntries = created.filter((r) => !r.wouldBlock);
+  const wouldBlockEntries = created.filter((r) => r.wouldBlock);
+  return buildBatchPreviewResult({
+    // Fix 1 (TEN-2918 follow-up): report the concrete `entryId` only when it was NOT
+    // auto-allocated (i.e. the caller supplied it for this item) — see WouldCaptureEntry's
+    // doc comment for why an auto-ID cannot be predicted per-item within a preview batch.
+    wouldCapture: wouldCaptureEntries.map((r) => ({
+      ...r.entryIdAssignedAtCapture ? { entryIdAssignedAtCapture: true } : { entryId: r.entryId },
+      collection: r.collection,
+      name: r.name,
+      ...r.classifiedBy ? { classifiedBy: r.classifiedBy } : {},
+      ...r.confidence != null ? { confidence: r.confidence } : {},
+      ...r.warnings?.length ? { warnings: r.warnings } : {}
+    })),
+    wouldBlock: wouldBlockEntries.map((r) => ({
+      ...r.entryIdAssignedAtCapture ? { entryIdAssignedAtCapture: true } : { entryId: r.entryId },
+      collection: r.collection,
+      name: r.name,
+      ...r.blockingReason ? { blockingReason: r.blockingReason } : {},
+      ...r.warnings?.length ? { warnings: r.warnings } : {}
+    })),
+    failed: failed.map((r) => ({ index: r.entryIdx, collection: r.collection, name: r.name, error: r.error ?? "unknown error" })),
+    skipped: skipped.map((s) => ({ index: s.index, name: s.name, ...s.suggestedCollection ? { suggestedCollection: s.suggestedCollection } : {}, ...s.confidence != null ? { confidence: s.confidence } : {} })),
+    requested,
+    // WP-577 review follow-up (P2, TEN-2918): thread the caller's original batch payload
+    // through so the "Capture for real" next-action can supply a non-empty `items` array —
+    // omitting it left the suggestion advertising `{ action: "batch" }` alone, which fails
+    // batchCaptureSchema's `.min(1)` items requirement the instant an agent follows it.
+    originalItems,
+    // Fix 1 (TEN-2918 follow-up): thread the batch's own autoCommit through unchanged.
+    originalAutoCommit
+  });
+}
+function buildBatchPreviewResult(input) {
+  const { wouldCapture, wouldBlock = [], failed, skipped, requested, originalItems, originalAutoCommit } = input;
+  const summary = buildBatchPreviewSummary(input);
+  const lines = [`# Batch Preview \u2014 No Entries Created`, summary, ""];
+  if (wouldCapture.length > 0) {
+    lines.push("## Would capture");
+    for (const r of wouldCapture) {
+      const classNote = r.classifiedBy && r.classifiedBy !== "explicit" ? ` (${r.classifiedBy}${r.confidence != null ? ` ${r.confidence}%` : ""})` : "";
+      const warnNote = r.warnings?.length ? ` \u2014 ${r.warnings.join("; ")}` : "";
+      const idNote = r.entryId ? `**${r.entryId}**: ` : "";
+      const assignedNote = r.entryIdAssignedAtCapture ? " (ID assigned at capture)" : "";
+      lines.push(`- ${idNote}**${r.name}** [${r.collection}]${classNote}${warnNote}${assignedNote}`);
+    }
+    lines.push("");
+  }
+  if (wouldBlock.length > 0) {
+    lines.push("## Would be BLOCKED");
+    for (const b of wouldBlock) {
+      const reasonNote = b.blockingReason ? ` \u2014 ${b.blockingReason}` : "";
+      const idNote = b.entryId ? `**${b.entryId}**: ` : "";
+      const assignedNote = b.entryIdAssignedAtCapture ? " (ID assigned at capture)" : "";
+      lines.push(`- ${idNote}**${b.name}** [${b.collection}]${reasonNote}${assignedNote}`);
+    }
+    lines.push("");
+  }
+  if (skipped.length > 0) {
+    lines.push("## Would be skipped \u2014 low confidence");
+    for (const s of skipped) {
+      const suggestion = s.suggestedCollection ? ` \u2014 best guess: \`${s.suggestedCollection}\`${s.confidence != null ? ` (${s.confidence}%)` : ""}` : " \u2014 no classification available";
+      lines.push(`- **[${s.index}]** ${s.name}${suggestion}`);
+    }
+    lines.push("");
+  }
+  if (failed.length > 0) {
+    lines.push("## Would fail");
+    for (const f of failed) {
+      lines.push(`- **[${f.index}]** ${f.name} [${f.collection}]: _${f.error}_`);
+    }
+    lines.push("");
+  }
+  lines.push("_No DB writes \u2014 call `capture action=batch` without `preview:true` to capture for real._");
+  const next = originalItems && originalItems.length > 0 ? [{
+    tool: "capture",
+    description: "Capture for real",
+    parameters: {
+      action: "batch",
+      items: originalItems,
+      // Fix 1 (WP-577 review round 3, TEN-2918 follow-up): preserve the batch's own
+      // autoCommit explicitly — `false` must survive (never dropped as falsy), and
+      // `undefined` (never supplied) is omitted so the server default still governs.
+      ...originalAutoCommit !== void 0 ? { autoCommit: originalAutoCommit } : {}
+    }
+  }] : [];
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      ...success(
+        summary,
+        {
+          outcome: "preview",
+          wouldCapture,
+          ...wouldBlock.length > 0 ? { wouldBlock } : {},
+          requested,
+          total: wouldCapture.length,
+          failed: failed.length,
+          ...skipped.length > 0 ? { skippedLowConfidence: skipped } : {},
+          ...failed.length > 0 ? { failedEntries: failed } : {}
+        },
+        next
+      )
+    }
+  };
+}
+
+// src/lib/createEntryPreviewResult.ts
+function isPreviewCreateEntryResult(result2) {
+  return "preview" in result2 && result2.preview === true;
+}
+function extractPreviewWouldBlock(result2, preview) {
+  return preview && result2 && isPreviewCreateEntryResult(result2) ? { wouldBlock: result2.wouldBlock === true, blockingReason: result2.blockingReason } : void 0;
+}
+function resolveEffectiveCollection(result2, preview, fallbackCollection) {
+  return preview && result2 && isPreviewCreateEntryResult(result2) ? result2.collection ?? fallbackCollection : fallbackCollection;
+}
+
+// src/lib/entryDataNormalization.ts
+function isEmptyValue(v) {
+  return v == null || (Array.isArray(v) ? v.length === 0 : String(v).trim() === "");
+}
+function isNonEmptyValue(v) {
+  return v != null && (Array.isArray(v) ? v.length > 0 : String(v).trim() !== "");
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+var APPETITE_OPTIONS = ["small", "medium", "large"];
+function findClosestOption(value, options) {
+  const lower = value.toLowerCase();
+  const exact = options.find((o) => o.toLowerCase() === lower);
+  if (exact) return { opt: exact, dist: 0 };
+  return options.reduce(
+    (acc, opt) => {
+      const d = levenshtein(lower, opt.toLowerCase());
+      return d < acc.dist ? { opt, dist: d } : acc;
+    },
+    { opt: options[0], dist: Infinity }
+  );
+}
+function canonicalizeSelects(data, fields, isBet) {
+  if (isBet && data.appetite != null && typeof data.appetite === "string") {
+    const val = data.appetite.trim();
+    if (val) {
+      const { opt, dist } = findClosestOption(val, APPETITE_OPTIONS);
+      if (dist <= 4) data.appetite = opt;
+    }
+  }
+  for (const field of fields) {
+    if (field.type !== "select" || !field.options?.length) continue;
+    if (field.key === "appetite" && isBet) continue;
+    const val = data[field.key];
+    if (val == null || typeof val !== "string") continue;
+    const trimmed = val.trim();
+    if (!trimmed) continue;
+    const { opt, dist } = findClosestOption(trimmed, field.options);
+    if (dist <= 4) data[field.key] = opt;
+  }
+}
+
+// src/lib/batchInlineRelations.ts
+async function applyBatchInlineRelations(relations, finalEntryId, preview, agentId) {
+  const result2 = {
+    relationsCreatedCount: 0,
+    relationsProposedCount: 0,
+    relationsNotValidatedCount: 0,
+    relationsFailedList: []
+  };
+  if (!relations || relations.length === 0) return result2;
+  if (preview) {
+    result2.relationsNotValidatedCount = relations.length;
+    return result2;
+  }
+  for (const rel of relations) {
+    try {
+      const relResult = await kernelMutation(
+        "chain.createEntryRelation",
+        {
+          fromEntryId: finalEntryId,
+          toEntryId: rel.to,
+          type: rel.type,
+          proposedBy: "user",
+          sessionId: agentId ?? void 0
+        }
+      );
+      if (relResult?.status === "agent_proposal_created") {
+        result2.relationsProposedCount++;
+      } else {
+        result2.relationsCreatedCount++;
+      }
+    } catch (relErr) {
+      const relMsg = relErr instanceof Error ? relErr.message : String(relErr);
+      result2.relationsFailedList.push(`${rel.to} (${rel.type}): ${relMsg}`);
+    }
+  }
+  return result2;
+}
+
+// src/lib/captureForRealAction.ts
+function buildCaptureForRealNextAction(payload) {
+  const {
+    collection,
+    name,
+    description,
+    context,
+    entryId,
+    canonicalKey,
+    data,
+    links,
+    autoCommit,
+    sourceRef,
+    sourceExcerpt,
+    ownerTeamEntryId,
+    ownerRoleEntryId
+  } = payload;
+  return [{
+    tool: "capture",
+    description: "Capture for real",
+    parameters: {
+      collection,
+      name,
+      description,
+      ...context ? { context } : {},
+      ...entryId ? { entryId } : {},
+      ...canonicalKey ? { canonicalKey } : {},
+      ...data && Object.keys(data).length > 0 ? { data } : {},
+      ...links && links.length > 0 ? { links } : {},
+      ...autoCommit !== void 0 ? { autoCommit } : {},
+      ...sourceRef ? { sourceRef } : {},
+      ...sourceExcerpt ? { sourceExcerpt } : {},
+      ...ownerTeamEntryId ? { ownerTeamEntryId } : {},
+      ...ownerRoleEntryId ? { ownerRoleEntryId } : {}
+    }
+  }];
+}
+
+// src/lib/rubricFormatting.ts
+function verdictQualityPhrase(result2) {
+  const v = result2?.verdict;
+  const criteria = v?.criteria ?? [];
+  if (!v || criteria.length === 0) {
+    return "Quality: not evaluated (no rubric for this type).";
+  }
+  const total = criteria.length;
+  const passed = criteria.filter((c) => c.passed).length;
+  return v.passed ? `Quality: all ${total} rubric criteria pass.` : `Quality: ${passed}/${total} rubric criteria pass \u2014 see the coaching above.`;
+}
+function formatRubricCoaching(result2) {
+  const { verdict, rogerMartin } = result2;
+  if (!verdict || verdict.criteria.length === 0) return "";
+  const lines = ["## Semantic Quality"];
+  const failed = (verdict.criteria ?? []).filter((c) => !c.passed);
+  const total = verdict.criteria?.length ?? 0;
+  const passedCount = total - failed.length;
+  if (verdict.passed) {
+    lines.push(`All ${total} rubric criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier).`);
+  } else {
+    lines.push(`${passedCount}/${total} criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier)`);
+    lines.push("");
+    for (const c of verdict.criteria) {
+      const icon = c.passed ? "[x]" : "[ ]";
+      const extra = c.passed ? "" : ` \u2014 ${c.hint}`;
+      lines.push(`${icon} ${c.id}${extra}`);
+    }
+    if (verdict.weakest) {
+      lines.push("");
+      lines.push(`**Coaching hint:** ${verdict.weakest.hint}`);
+      lines.push(`_Question to consider:_ ${verdict.weakest.questionTemplate}`);
+    }
+  }
+  if (rogerMartin) {
+    lines.push("");
+    lines.push("### Roger Martin Test");
+    if (rogerMartin.isStrategicChoice) {
+      lines.push("This principle passes \u2014 the opposite is a reasonable strategic choice.");
+    } else {
+      lines.push(`This principle may not be a strategic choice. ${rogerMartin.reasoning}`);
+      if (rogerMartin.suggestion) {
+        lines.push(`_Suggestion:_ ${rogerMartin.suggestion}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatRubricVerdictSection(verdict) {
+  if (!verdict || !verdict.criteria || verdict.criteria.length === 0) return "";
+  const lines = ["## Semantic Quality"];
+  const failed = verdict.criteria.filter((c) => !c.passed);
+  const total = verdict.criteria.length;
+  const passedCount = total - failed.length;
+  const durationSuffix = verdict.llmDurationMs ? ` in ${(verdict.llmDurationMs / 1e3).toFixed(1)}s` : "";
+  const statusNote = verdict.llmStatus === "pending" ? " \u2014 LLM evaluation in progress..." : verdict.llmStatus === "failed" ? ` \u2014 LLM evaluation failed${verdict.llmError ? `: ${verdict.llmError}` : ""}, showing heuristic results` : verdict.source === "llm" && durationSuffix ? ` \u2014 evaluated${durationSuffix}` : "";
+  if (failed.length === 0) {
+    lines.push(`All ${total} rubric criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier, ${verdict.source} evaluation).${statusNote}`);
+  } else {
+    lines.push(`${passedCount}/${total} criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier, ${verdict.source} evaluation)${statusNote}`);
+    lines.push("");
+    for (const c of verdict.criteria) {
+      const icon = c.passed ? "[x]" : "[ ]";
+      const extra = c.passed ? "" : ` \u2014 ${c.hint}`;
+      lines.push(`${icon} ${c.id}${extra}`);
+    }
+    if (verdict.weakest) {
+      lines.push("");
+      lines.push(`**Top improvement:** ${verdict.weakest.hint}`);
+    }
+  }
+  if (verdict.rogerMartin) {
+    const rm = verdict.rogerMartin;
+    lines.push("");
+    lines.push("### Roger Martin Test");
+    if (rm.isStrategicChoice) {
+      lines.push(`This is a real strategic choice \u2014 the opposite is reasonable. ${rm.reasoning}`);
+    } else {
+      lines.push(`This may not be a strategic choice. ${rm.reasoning}`);
+      if (rm.suggestion) {
+        lines.push(`_Suggestion:_ ${rm.suggestion}`);
+      }
+    }
   }
-  return failureResult(
-    lines.join("\n"),
-    "COHERENCY_REFUSED",
-    `Coherency gate refused ${toolName} on ${entryId}.`,
-    "Use one of the refusal's routes (link / coherencyAcknowledgement / steeringOverrideReason), then retry.",
-    void 0,
-    { entryId, refusal }
-  );
-}
-
-// src/lib/resolveCollection.ts
-async function resolveCollection(params) {
-  const { name, description, typeHint, allowReviewRouting } = params;
-  const sessionId = getAgentSessionId();
-  const result2 = await kernelCall("chain.resolveCollection", {
-    entryName: name,
-    entryDescription: description,
-    ...typeHint ? { typeHint } : {},
-    ...allowReviewRouting ? { allowReviewRouting } : {},
-    ...sessionId ? { agentSessionId: sessionId } : {}
-  });
-  return result2 ?? null;
+  return lines.join("\n");
 }
 
-// src/lib/fieldTypes.ts
-var FIELD_TYPE_DEFAULTS = {
-  "string": "",
-  "text": "",
-  "rich-text": "",
-  "number": null,
-  "boolean": false,
-  "select": null,
-  "multi-select": [],
-  "array": [],
-  "json": null,
-  "date": null,
-  "person": null
-};
+// src/lib/captureSinglePreviewOutput.ts
+import { z as z3 } from "zod/v3";
+var groundingRelatedEntrySchema = z3.object({
+  entryId: z3.string(),
+  name: z3.string(),
+  collectionSlug: z3.string(),
+  overlapRatio: z3.number(),
+  recommendedRelationType: z3.string(),
+  reasoning: z3.string()
+});
+var groundingDuplicateEntrySchema = z3.object({
+  entryId: z3.string(),
+  name: z3.string(),
+  collectionSlug: z3.string(),
+  matchType: z3.enum(["related", "possible_duplicate"]),
+  overlapRatio: z3.number()
+});
+var groundingGovernanceEntrySchema = z3.object({
+  entryId: z3.string(),
+  name: z3.string(),
+  collectionSlug: z3.string()
+});
+var groundingReportSchema = z3.object({
+  related: z3.array(groundingRelatedEntrySchema),
+  duplicates: z3.array(groundingDuplicateEntrySchema),
+  governance: z3.array(groundingGovernanceEntrySchema)
+});
+var taskAlignmentSchema = z3.record(z3.unknown());
+var captureSinglePreviewOutputSchema = z3.object({
+  entryId: z3.string(),
+  name: z3.string(),
+  collection: z3.string(),
+  outcome: z3.enum(["preview", "blocked"]),
+  // Present only when `outcome: "blocked"` AND the server supplied a reason.
+  blockingReason: z3.string().optional(),
+  // Always present — `result.warnings ?? []`, never omitted.
+  warnings: z3.array(z3.string()),
+  groundingReport: groundingReportSchema,
+  // TEN-2458: only present when the kernel computed a librarian verdict for this preview.
+  taskAlignment: taskAlignmentSchema.optional()
+}).strict();
 
-// src/lib/formatFieldGuidance.ts
-function formatFieldGuidance(fields) {
-  const guidedFields = fields.filter((f) => f.writingGuidance);
-  if (guidedFields.length === 0) return "";
-  const lines = ["## Writing Guidance"];
-  for (const field of guidedFields) {
-    const displayName = field.label || field.key;
-    lines.push(`- ${displayName}: ${field.writingGuidance}`);
-    if (field.writingExamples && field.writingExamples.length > 0) {
-      lines.push(`  Examples: ${field.writingExamples.join(" | ")}`);
+// src/lib/batchPreviewDuplicates.ts
+function createBatchPreviewDuplicateTracker() {
+  const seenByCollection = /* @__PURE__ */ new Map();
+  const seenEntryIds = /* @__PURE__ */ new Set();
+  return {
+    isDuplicateName(collection, name) {
+      return seenByCollection.get(collection)?.has(name) ?? false;
+    },
+    recordName(collection, name) {
+      let names = seenByCollection.get(collection);
+      if (!names) {
+        names = /* @__PURE__ */ new Set();
+        seenByCollection.set(collection, names);
+      }
+      names.add(name);
+    },
+    isDuplicateEntryId(entryId) {
+      return seenEntryIds.has(entryId);
+    },
+    recordEntryId(entryId) {
+      seenEntryIds.add(entryId);
     }
-  }
-  return lines.join("\n");
-}
-
-// src/lib/inferSourceDate.ts
-function inferSourceDate(...values) {
-  const combined = values.filter((value) => typeof value === "string" && value.trim().length > 0).join("\n");
-  if (!combined) return void 0;
-  const isoMatch = combined.match(/\b(20\d{2}-\d{2}-\d{2})\b/);
-  if (isoMatch) return isoMatch[1];
-  const monthMatch = combined.match(
-    /\b(january|february|march|april|may|june|july|august|september|october|november|december)\s+(\d{1,2})(?:st|nd|rd|th)?(?:,?\s+(20\d{2}))?\b/i
-  );
-  if (!monthMatch) return void 0;
-  const monthIndex = [
-    "january",
-    "february",
-    "march",
-    "april",
-    "may",
-    "june",
-    "july",
-    "august",
-    "september",
-    "october",
-    "november",
-    "december"
-  ].indexOf(monthMatch[1].toLowerCase());
-  if (monthIndex < 0) return void 0;
-  const inferredYear = monthMatch[3] ?? combined.match(/\b(20\d{2})\b/)?.[1] ?? String((/* @__PURE__ */ new Date()).getUTCFullYear());
-  const month = String(monthIndex + 1).padStart(2, "0");
-  const day = monthMatch[2].padStart(2, "0");
-  return `${inferredYear}-${month}-${day}`;
+  };
 }
-
-// src/lib/collectionCache.ts
-var collectionCache = new ScopedCache(COLLECTION_CACHE_TTL_MS);
-async function getCollections() {
-  const scope = cacheScope();
-  const hit = collectionCache.get(scope);
-  if (hit) return hit.collections;
-  const result2 = await kernelQuery("chain.listCollections") ?? [];
-  const bySlug = new Map(result2.map((c) => [c.slug, c]));
-  collectionCache.set(scope, { collections: result2, bySlug });
-  return result2;
+function buildBatchPreviewDuplicateResult(entryIdx, name, collection, classifiedBy, confidence, confidenceTier) {
+  return {
+    entryIdx,
+    name,
+    collection,
+    entryId: "",
+    ok: false,
+    autoLinks: 0,
+    advisedLinks: 0,
+    status: "draft",
+    classifiedBy,
+    confidence,
+    confidenceTier,
+    error: `Duplicate entry: "${name}" already claimed by an earlier item in this batch [${collection}] \u2014 the real (non-preview) run would write the first and reject this one.`
+  };
 }
-async function getCollectionBySlug(slug) {
-  await getCollections();
-  return collectionCache.get(cacheScope())?.bySlug.get(slug);
+function buildBatchPreviewDuplicateEntryIdResult(entryIdx, name, collection, entryId, classifiedBy, confidence, confidenceTier) {
+  return {
+    entryIdx,
+    name,
+    collection,
+    entryId: "",
+    ok: false,
+    autoLinks: 0,
+    advisedLinks: 0,
+    status: "draft",
+    classifiedBy,
+    confidence,
+    confidenceTier,
+    error: `Duplicate entry: ID "${entryId}" already claimed by an earlier item in this batch (workspace-wide) \u2014 the real (non-preview) run would write the first and reject this one.`
+  };
 }
-function invalidateCollectionCacheForScope() {
-  collectionCache.delete(cacheScope());
+function checkBatchPreviewDuplicate(tracker, args) {
+  if (!args.preview) return null;
+  if (args.callerEntryId && tracker.isDuplicateEntryId(args.callerEntryId)) {
+    return buildBatchPreviewDuplicateEntryIdResult(
+      args.entryIdx,
+      args.name,
+      args.collection,
+      args.callerEntryId,
+      args.classifiedBy,
+      args.confidence,
+      args.confidenceTier
+    );
+  }
+  if (tracker.isDuplicateName(args.collection, args.name)) {
+    return buildBatchPreviewDuplicateResult(
+      args.entryIdx,
+      args.name,
+      args.collection,
+      args.classifiedBy,
+      args.confidence,
+      args.confidenceTier
+    );
+  }
+  return null;
 }
-async function isGoverned(slug) {
-  const col = await getCollectionBySlug(slug);
-  return !!col?.governed;
+function recordBatchPreviewIfConfirmed(tracker, args) {
+  if (!args.wouldCapture) return;
+  tracker.recordName(args.effectiveCollection, args.name);
+  if (args.callerEntryId) tracker.recordEntryId(args.callerEntryId);
+}
+function reconcileBatchPreviewDuplicate(tracker, args) {
+  if (args.wouldCapture && tracker.isDuplicateName(args.effectiveCollection, args.name)) {
+    return buildBatchPreviewDuplicateResult(
+      args.entryIdx,
+      args.name,
+      args.effectiveCollection,
+      args.classifiedBy,
+      args.confidence,
+      args.confidenceTier
+    );
+  }
+  recordBatchPreviewIfConfirmed(tracker, {
+    wouldCapture: args.wouldCapture,
+    effectiveCollection: args.effectiveCollection,
+    name: args.name,
+    callerEntryId: args.callerEntryId
+  });
+  return null;
 }
 
 // src/tools/smart-capture.ts
@@ -828,81 +1522,81 @@ var AUTO_LINK_CONFIDENCE_THRESHOLD = 35;
 var MAX_AUTO_LINKS = 5;
 var MAX_SUGGESTIONS = 5;
 var BR_STD_ENTRY_ID_REGEX = /^(BR|STD)-\d+$/;
-var entryIdSchema = z2.string().regex(BR_STD_ENTRY_ID_REGEX).optional().describe("Only for business-rules and standards. Must match BR-NNN or STD-NNN. Omit for all other collections \u2014 IDs are auto-generated.");
-var captureSchema = z2.object({
-  collection: z2.string().optional().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional \u2014 classifier auto-routes when omitted."),
-  name: z2.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
-  description: z2.string().describe("Full context \u2014 what's happening, why it matters, what you observed"),
-  context: z2.string().optional().describe("Optional additional context (e.g. 'Observed during context gather calls taking 700ms+')"),
+var entryIdSchema = z4.string().regex(BR_STD_ENTRY_ID_REGEX).optional().describe("Only for business-rules and standards. Must match BR-NNN or STD-NNN. Omit for all other collections \u2014 IDs are auto-generated.");
+var captureSchema = z4.object({
+  collection: z4.string().optional().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional \u2014 classifier auto-routes when omitted."),
+  name: z4.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
+  description: z4.string().describe("Full context \u2014 what's happening, why it matters, what you observed"),
+  context: z4.string().optional().describe("Optional additional context (e.g. 'Observed during context gather calls taking 700ms+')"),
   entryId: entryIdSchema,
-  canonicalKey: z2.string().optional().describe("Semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted."),
-  data: z2.record(z2.unknown()).optional().describe("Explicit field values when you know the schema (e.g. canonical_key, cardinality_rule, required_fields). Merged with inferred values; user-provided wins."),
-  links: z2.array(z2.object({
-    to: z2.string().describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
-    type: z2.string().describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
+  canonicalKey: z4.string().optional().describe("Semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted."),
+  data: z4.record(z4.unknown()).optional().describe("Explicit field values when you know the schema (e.g. canonical_key, cardinality_rule, required_fields). Merged with inferred values; user-provided wins."),
+  links: z4.array(z4.object({
+    to: z4.string().describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
+    type: z4.string().describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
   })).optional().describe("Relations to create after capture. Skips auto-link discovery when provided."),
-  autoCommit: z2.boolean().optional().describe("If true, commits the entry immediately after capture + linking. If omitted, Open mode workspaces auto-commit by default and consensus/role modes stay draft-first."),
-  sourceRef: z2.string().optional().describe("URI or path of the source document backing this entry (e.g. 'meeting-2026-03-28.md', 'import://batch-5'). Stored as top-level entry field, not in data."),
-  sourceExcerpt: z2.string().optional().describe("Verbatim excerpt from the source that backs this entry's claims. Stored as top-level entry field, not in data."),
+  autoCommit: z4.boolean().optional().describe("If true, commits the entry immediately after capture + linking. If omitted, Open mode workspaces auto-commit by default and consensus/role modes stay draft-first."),
+  sourceRef: z4.string().optional().describe("URI or path of the source document backing this entry (e.g. 'meeting-2026-03-28.md', 'import://batch-5'). Stored as top-level entry field, not in data."),
+  sourceExcerpt: z4.string().optional().describe("Verbatim excerpt from the source that backs this entry's claims. Stored as top-level entry field, not in data."),
   // WP-316 S3: Preview gate — dry-run mode. Returns what would happen, no DB writes.
-  preview: z2.boolean().optional().describe("If true, validates the capture without writing. Returns what would happen. Default false."),
+  preview: z4.boolean().optional().describe("If true, validates the capture without writing. Returns what would happen. Default false."),
   // WP-318 S2: Pre-write grounding — run link suggestion before creating entry.
-  suggestOnly: z2.boolean().optional().describe("If true, runs pre-write grounding (suggestLinksForCapture) and returns a groundingReport WITHOUT creating any entry. Use to preview graph participation before accepting. Default false."),
+  suggestOnly: z4.boolean().optional().describe("If true, runs pre-write grounding (suggestLinksForCapture) and returns a groundingReport WITHOUT creating any entry. Use to preview graph participation before accepting. Default false."),
   // WP-318 S2: Format for groundingReport in response.
-  format: z2.enum(["agent", "human"]).optional().describe("Response format for grounding data. 'agent' (default): full JSON groundingReport. 'human': compressed summary string appended to the capture summary."),
+  format: z4.enum(["agent", "human"]).optional().describe("Response format for grounding data. 'agent' (default): full JSON groundingReport. 'human': compressed summary string appended to the capture summary."),
   // WP-513: team+role to create AS OWNER of (rung 2 only); no-op pre-rung-2.
-  ownerTeamEntryId: z2.string().max(200).optional().describe("Owning team entry ID/ref (rung 2)."),
-  ownerRoleEntryId: z2.string().max(200).optional().describe("Owning role entry ID/ref (rung 2).")
+  ownerTeamEntryId: z4.string().max(200).optional().describe("Owning team entry ID/ref (rung 2)."),
+  ownerRoleEntryId: z4.string().max(200).optional().describe("Owning role entry ID/ref (rung 2).")
 });
-var batchCaptureRelationSchema = z2.object({
-  to: z2.string().max(200).describe("Target entry ID already on the Chain, e.g. '<PREFIX>-<n>'."),
-  type: z2.string().max(200).describe("Relation type, e.g. 'related_to', 'informed_by', 'governs'.")
+var batchCaptureRelationSchema = z4.object({
+  to: z4.string().max(200).describe("Target entry ID already on the Chain, e.g. '<PREFIX>-<n>'."),
+  type: z4.string().max(200).describe("Relation type, e.g. 'related_to', 'informed_by', 'governs'.")
 });
-var batchCaptureSchema = z2.object({
-  entries: z2.array(z2.object({
+var batchCaptureSchema = z4.object({
+  entries: z4.array(z4.object({
     // FEAT-160
-    collection: z2.string().max(200).optional().describe("Collection slug. Optional \u2014 auto-classified via LLM when omitted."),
-    name: z2.string().max(500).describe("Display name"),
-    description: z2.string().max(2e4).describe("Full context / definition"),
+    collection: z4.string().max(200).optional().describe("Collection slug. Optional \u2014 auto-classified via LLM when omitted."),
+    name: z4.string().max(500).describe("Display name"),
+    description: z4.string().max(2e4).describe("Full context / definition"),
     entryId: entryIdSchema,
-    data: z2.record(z2.unknown()).optional().describe("Explicit field values (e.g. urgency, status, assignee). Merged with inferred values; user-provided wins."),
-    canonicalKey: z2.string().max(200).optional().describe("Semantic type (e.g. 'decision', 'tension', 'work_package'). Enables work-package redirect in createEntry when collection is 'chains'."),
-    sourceRef: z2.string().max(2e3).optional().describe("URI or path of the source document backing this entry (e.g. 'meeting-2026-03-28.md', 'import://batch-5'). Stored as top-level entry field, not in data."),
-    sourceExcerpt: z2.string().max(5e3).optional().describe("Verbatim excerpt from the source that backs this entry's claims. Stored as top-level entry field, not in data."),
+    data: z4.record(z4.unknown()).optional().describe("Explicit field values (e.g. urgency, status, assignee). Merged with inferred values; user-provided wins."),
+    canonicalKey: z4.string().max(200).optional().describe("Semantic type (e.g. 'decision', 'tension', 'work_package'). Enables work-package redirect in createEntry when collection is 'chains'."),
+    sourceRef: z4.string().max(2e3).optional().describe("URI or path of the source document backing this entry (e.g. 'meeting-2026-03-28.md', 'import://batch-5'). Stored as top-level entry field, not in data."),
+    sourceExcerpt: z4.string().max(5e3).optional().describe("Verbatim excerpt from the source that backs this entry's claims. Stored as top-level entry field, not in data."),
     // TEN-957 (WP-484 S2): relations to create right after this entry is captured.
-    relations: z2.array(batchCaptureRelationSchema).max(10).optional().describe("Relations to create right after this entry is captured \u2014 each {to, type} links the NEW entry to an existing Chain entry."),
+    relations: z4.array(batchCaptureRelationSchema).max(10).optional().describe("Relations to create right after this entry is captured \u2014 each {to, type} links the NEW entry to an existing Chain entry."),
     // WP-513: team+role to create THIS entry AS OWNER of (rung 2 only).
-    ownerTeamEntryId: z2.string().max(200).optional().describe("Owning team entry ID/ref (rung 2)."),
-    ownerRoleEntryId: z2.string().max(200).optional().describe("Owning role entry ID/ref (rung 2).")
+    ownerTeamEntryId: z4.string().max(200).optional().describe("Owning team entry ID/ref (rung 2)."),
+    ownerRoleEntryId: z4.string().max(200).optional().describe("Owning role entry ID/ref (rung 2).")
   })).min(1).max(50).describe("Array of entries to capture"),
-  autoCommit: z2.boolean().optional().describe(
+  autoCommit: z4.boolean().optional().describe(
     "If true, commits created entries immediately after linking. If omitted, Open mode workspaces commit by default and consensus/role modes stay draft-first."
   ),
   // WP-316 S3: Preview gate — dry-run mode. Returns what would happen, no DB writes.
-  preview: z2.boolean().optional().describe("If true, validates all captures without writing. Returns what would happen. Default false.")
+  preview: z4.boolean().optional().describe("If true, validates all captures without writing. Returns what would happen. Default false.")
 });
-var captureClassifierSchema = z2.object({
-  enabled: z2.boolean(),
-  autoRouted: z2.boolean(),
-  agrees: z2.boolean(),
-  abstained: z2.boolean(),
-  topConfidence: z2.number(),
-  confidence: z2.number(),
-  reasons: z2.array(z2.string()),
-  candidates: z2.array(
-    z2.object({
-      collection: z2.string(),
-      signalScore: z2.number().optional(),
-      confidence: z2.number(),
+var captureClassifierSchema = z4.object({
+  enabled: z4.boolean(),
+  autoRouted: z4.boolean(),
+  agrees: z4.boolean(),
+  abstained: z4.boolean(),
+  topConfidence: z4.number(),
+  confidence: z4.number(),
+  reasons: z4.array(z4.string()),
+  candidates: z4.array(
+    z4.object({
+      collection: z4.string(),
+      signalScore: z4.number().optional(),
+      confidence: z4.number(),
       /** WP-316 S2: required-field cost — how many fields the agent must supply for this collection. */
-      requiredFieldCount: z2.number().optional()
+      requiredFieldCount: z4.number().optional()
     })
   ),
-  agentProvidedCollection: z2.string().optional(),
-  overrideCommand: z2.string().optional(),
-  classifiedBy: z2.enum(["llm", "heuristic", "explicit"]).optional(),
-  confidenceTier: z2.enum(["high", "medium", "low"]).optional(),
-  reasoning: z2.string().optional()
+  agentProvidedCollection: z4.string().optional(),
+  overrideCommand: z4.string().optional(),
+  classifiedBy: z4.enum(["llm", "heuristic", "explicit"]).optional(),
+  confidenceTier: z4.enum(["high", "medium", "low"]).optional(),
+  reasoning: z4.string().optional()
 });
 function trackClassifierTelemetry(params) {
   const telemetry = {
@@ -1130,106 +1824,55 @@ async function resolveCaptureCollection(params) {
     classifierMeta
   };
 }
-var captureSuccessOutputSchema = z2.object({
-  entryId: z2.string(),
-  collection: z2.string(),
-  name: z2.string(),
+var captureSuccessOutputSchema = z4.object({
+  entryId: z4.string(),
+  collection: z4.string(),
+  name: z4.string(),
   // "draft_on_failure" is the status emitted when an auto-commit is REFUSED/failed (the entry
   // stays a draft) — the same path that now also emits coherencyRefusal. The strict schema must
   // accept it or a refused response fails to validate on `status` (codex review, completing the
   // coherencyRefusal contract fix).
-  status: z2.enum(["draft", "committed", "proposed", "draft_on_failure"]),
+  status: z4.enum(["draft", "committed", "proposed", "draft_on_failure"]),
   // WP-480 S1: `qualityScore` (required, client N/10) deleted — a named, accepted
   // breaking output-contract change. The server verdict stays as `qualityVerdict`.
-  qualityVerdict: z2.record(z2.unknown()).optional(),
+  qualityVerdict: z4.record(z4.unknown()).optional(),
   classifier: captureClassifierSchema.optional(),
-  studioUrl: z2.string().optional(),
-  warnings: z2.array(z2.string()).optional(),
-  normalization: z2.object({
-    remapped: z2.record(z2.string()).optional(),
-    rejected: z2.array(z2.string()).optional()
+  studioUrl: z4.string().optional(),
+  warnings: z4.array(z4.string()).optional(),
+  normalization: z4.object({
+    remapped: z4.record(z4.string()).optional(),
+    rejected: z4.array(z4.string()).optional()
   }).optional(),
-  expectedFields: z2.array(z2.object({
-    key: z2.string(),
-    type: z2.string(),
-    required: z2.boolean().optional()
+  expectedFields: z4.array(z4.object({
+    key: z4.string(),
+    type: z4.string(),
+    required: z4.boolean().optional()
   })).optional(),
   // TEN-2365: capture-time authority-domain proposal (PENDING ratification), when one was filed.
-  authorityDomain: z2.object({
-    slug: z2.string(),
-    status: z2.literal("proposal-pending")
+  authorityDomain: z4.object({
+    slug: z4.string(),
+    status: z4.literal("proposal-pending")
   }).optional(),
   // WP-465 surface parity: structured coherency refusal when an auto-commit is gate-refused.
   // Loose record (matching the qualityVerdict convention above) — the CoherencyRefusal contract
   // is authored in convex/lib/gates/coherencyControls.ts; re-declaring its shape here would create
   // a second source of truth. Required because the schema is `.strict()` (an undeclared key throws).
-  coherencyRefusal: z2.record(z2.unknown()).optional(),
+  coherencyRefusal: z4.record(z4.unknown()).optional(),
   // WP-485 Slice 2b round 4 (Codex P2, FEAT-1370): the server's contradiction advisory
   // (ContradictionAdvisory, declared below) is emitted into structuredContent at line ~2203
   // but was missing here — since this schema is `.strict()`, any real capture response
   // carrying the advisory failed validation outright with `unrecognized_keys`. Loose record,
   // same single-source-of-truth rationale as coherencyRefusal above.
-  contradictionAdvisory: z2.record(z2.unknown()).optional()
+  contradictionAdvisory: z4.record(z4.unknown()).optional()
 }).strict();
-var captureClassifierOnlyOutputSchema = z2.object({
+var captureClassifierOnlyOutputSchema = z4.object({
   classifier: captureClassifierSchema
 }).strict();
-var captureOutputSchema = z2.union([
+var captureOutputSchema = z4.union([
   captureSuccessOutputSchema,
+  captureSinglePreviewOutputSchema,
   captureClassifierOnlyOutputSchema
 ]);
-var batchCaptureOutputSchema = z2.object({
-  captured: z2.array(z2.object({
-    entryId: z2.string(),
-    collection: z2.string(),
-    name: z2.string(),
-    // "draft_on_failure" is the status emitted when an auto-commit is REFUSED/failed (the entry
-    // stays a draft) — the same path that now also emits coherencyRefusal. The strict schema must
-    // accept it or a refused response fails to validate on `status` (codex review, completing the
-    // coherencyRefusal contract fix).
-    status: z2.enum(["draft", "committed", "proposed", "draft_on_failure"]),
-    classifiedBy: z2.enum(["llm", "heuristic", "explicit"]).optional(),
-    confidence: z2.number().optional(),
-    confidenceTier: z2.enum(["high", "medium", "low"]).optional(),
-    warnings: z2.array(z2.string()).optional(),
-    normalization: z2.object({
-      remapped: z2.record(z2.string()).optional(),
-      rejected: z2.array(z2.string()).optional()
-    }).optional(),
-    // TEN-2365: capture-time authority-domain proposal slug (PENDING ratification), when filed.
-    domain: z2.string().optional(),
-    // WP-465 surface parity: structured coherency refusal for a gate-refused auto-commit (batch
-    // shape). Loose record — same single-source rationale as captureSuccessOutputSchema above.
-    coherencyRefusal: z2.record(z2.unknown()).optional(),
-    // WP-485 Slice 2b round 4 (Codex P2, FEAT-1370): per-entry contradiction advisory, emitted
-    // into structuredContent at line ~2967 but undeclared here. Not `.strict()` so this one was
-    // silently stripped rather than rejected — declared anyway so batch consumers actually see it.
-    contradictionAdvisory: z2.record(z2.unknown()).optional()
-  })),
-  total: z2.number(),
-  failed: z2.number(),
-  committed: z2.number(),
-  proposed: z2.number(),
-  drafts: z2.number(),
-  classified: z2.number().optional(),
-  autoCommitApplied: z2.boolean(),
-  skippedLowConfidence: z2.array(z2.object({
-    index: z2.number(),
-    name: z2.string(),
-    suggestedCollection: z2.string().optional(),
-    confidence: z2.number().optional(),
-    alternatives: z2.array(z2.object({
-      collection: z2.string(),
-      confidence: z2.number()
-    })).optional()
-  })).optional(),
-  failedEntries: z2.array(z2.object({
-    index: z2.number(),
-    collection: z2.string(),
-    name: z2.string(),
-    error: z2.string()
-  })).optional()
-});
 function shouldAutoCommitCapture(autoCommit, governanceMode) {
   if (governanceMode !== "open") return false;
   return autoCommit === true || autoCommit === void 0;
@@ -1245,94 +1888,42 @@ function buildDataFromFields(fields, descriptionField, descriptionValue) {
   }
   return data;
 }
-function isEmptyValue(v) {
-  return v == null || (Array.isArray(v) ? v.length === 0 : String(v).trim() === "");
-}
-function isNonEmptyValue(v) {
-  return v != null && (Array.isArray(v) ? v.length > 0 : String(v).trim() !== "");
-}
-function levenshtein(a, b) {
-  const m = a.length;
-  const n = b.length;
-  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
-    }
-  }
-  return dp[m][n];
-}
-var APPETITE_OPTIONS = ["small", "medium", "large"];
-function findClosestOption(value, options) {
-  const lower = value.toLowerCase();
-  const exact = options.find((o) => o.toLowerCase() === lower);
-  if (exact) return { opt: exact, dist: 0 };
-  return options.reduce(
-    (acc, opt) => {
-      const d = levenshtein(lower, opt.toLowerCase());
-      return d < acc.dist ? { opt, dist: d } : acc;
-    },
-    { opt: options[0], dist: Infinity }
-  );
-}
-function canonicalizeSelects(data, fields, isBet) {
-  if (isBet && data.appetite != null && typeof data.appetite === "string") {
-    const val = data.appetite.trim();
-    if (val) {
-      const { opt, dist } = findClosestOption(val, APPETITE_OPTIONS);
-      if (dist <= 4) data.appetite = opt;
-    }
-  }
-  for (const field of fields) {
-    if (field.type !== "select" || !field.options?.length) continue;
-    if (field.key === "appetite" && isBet) continue;
-    const val = data[field.key];
-    if (val == null || typeof val !== "string") continue;
-    const trimmed = val.trim();
-    if (!trimmed) continue;
-    const { opt, dist } = findClosestOption(trimmed, field.options);
-    if (dist <= 4) data[field.key] = opt;
-  }
-}
 var CAPTURE_ACTIONS = ["capture", "batch"];
 var captureItemSchema = batchCaptureSchema.shape.entries.element;
-var captureCompoundSchema = z2.object({
-  action: z2.enum(CAPTURE_ACTIONS).optional().default("capture").describe("'capture': create a single knowledge entry (the original capture behavior). 'batch': create multiple entries in one call via `items[]` (absorbs batch-capture; each item may carry inline `relations`)."),
+var captureCompoundSchema = z4.object({
+  action: z4.enum(CAPTURE_ACTIONS).optional().default("capture").describe("'capture': create a single knowledge entry (the original capture behavior). 'batch': create multiple entries in one call via `items[]` (absorbs batch-capture; each item may carry inline `relations`)."),
   // For 'capture' — mirrors captureSchema, relaxed to optional (batch omits these).
-  collection: z2.string().max(200).optional().describe("For 'capture': collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional \u2014 classifier auto-routes when omitted."),
-  name: z2.string().max(500).optional().describe("For 'capture': display name \u2014 required for this action."),
-  description: z2.string().max(2e4).optional().describe("For 'capture': full context \u2014 required for this action."),
-  context: z2.string().max(5e3).optional().describe("For 'capture': optional additional context."),
+  collection: z4.string().max(200).optional().describe("For 'capture': collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional \u2014 classifier auto-routes when omitted."),
+  name: z4.string().max(500).optional().describe("For 'capture': display name \u2014 required for this action."),
+  description: z4.string().max(2e4).optional().describe("For 'capture': full context \u2014 required for this action."),
+  context: z4.string().max(5e3).optional().describe("For 'capture': optional additional context."),
   entryId: entryIdSchema,
-  canonicalKey: z2.string().max(200).optional().describe("For 'capture': semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted."),
-  data: z2.record(z2.unknown()).optional().describe("For 'capture': explicit field values. Merged with inferred values; user-provided wins."),
-  links: z2.array(z2.object({
-    to: z2.string().max(200).describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
-    type: z2.string().max(200).describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
+  canonicalKey: z4.string().max(200).optional().describe("For 'capture': semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted."),
+  data: z4.record(z4.unknown()).optional().describe("For 'capture': explicit field values. Merged with inferred values; user-provided wins."),
+  links: z4.array(z4.object({
+    to: z4.string().max(200).describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
+    type: z4.string().max(200).describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
   })).max(20).optional().describe("For 'capture': relations to create after capture. Skips auto-link discovery when provided."),
-  autoCommit: z2.boolean().optional().describe("For 'capture'/'batch': if true, commits immediately after capture + linking."),
-  sourceRef: z2.string().max(2e3).optional().describe("For 'capture': URI or path of the source document backing this entry."),
-  sourceExcerpt: z2.string().max(5e3).optional().describe("For 'capture': verbatim excerpt from the source backing this entry's claims."),
-  preview: z2.boolean().optional().describe("For 'capture'/'batch': if true, validates without writing."),
-  suggestOnly: z2.boolean().optional().describe("For 'capture': if true, runs pre-write grounding and returns a groundingReport WITHOUT creating any entry."),
-  format: z2.enum(["agent", "human"]).optional().describe("For 'capture': response format for grounding data."),
+  autoCommit: z4.boolean().optional().describe("For 'capture'/'batch': if true, commits immediately after capture + linking."),
+  sourceRef: z4.string().max(2e3).optional().describe("For 'capture': URI or path of the source document backing this entry."),
+  sourceExcerpt: z4.string().max(5e3).optional().describe("For 'capture': verbatim excerpt from the source backing this entry's claims."),
+  preview: z4.boolean().optional().describe("For 'capture'/'batch': if true, validates without writing."),
+  suggestOnly: z4.boolean().optional().describe("For 'capture': if true, runs pre-write grounding and returns a groundingReport WITHOUT creating any entry."),
+  format: z4.enum(["agent", "human"]).optional().describe("For 'capture': response format for grounding data."),
   // For 'batch' — mirrors batchCaptureSchema's `entries`, renamed `items` per §3.
-  items: z2.array(captureItemSchema).min(1).max(50).optional().describe("For 'batch': array of entries to capture, each may carry inline `relations`."),
+  items: z4.array(captureItemSchema).min(1).max(50).optional().describe("For 'batch': array of entries to capture, each may carry inline `relations`."),
   // WP-513: team+role to create AS OWNER of (rung 2 only).
-  ownerTeamEntryId: z2.string().max(200).optional().describe("For 'capture': owning team (rung-2)."),
-  ownerRoleEntryId: z2.string().max(200).optional().describe("For 'capture': owning role (rung-2).")
+  ownerTeamEntryId: z4.string().max(200).optional().describe("For 'capture': owning team (rung-2)."),
+  ownerRoleEntryId: z4.string().max(200).optional().describe("For 'capture': owning role (rung-2).")
 });
-var captureSingleVariant = captureSchema.extend({ action: z2.literal("capture") });
-var captureBatchVariant = z2.object({
-  action: z2.literal("batch"),
-  items: z2.array(captureItemSchema).min(1).max(50),
-  autoCommit: z2.boolean().optional(),
-  preview: z2.boolean().optional()
+var captureSingleVariant = captureSchema.extend({ action: z4.literal("capture") });
+var captureBatchVariant = z4.object({
+  action: z4.literal("batch"),
+  items: z4.array(captureItemSchema).min(1).max(50),
+  autoCommit: z4.boolean().optional(),
+  preview: z4.boolean().optional()
 });
-var captureActionUnion = z2.discriminatedUnion("action", [
+var captureActionUnion = z4.discriminatedUnion("action", [
   captureSingleVariant,
   captureBatchVariant
 ]);
@@ -1500,7 +2091,23 @@ ${groundingReport.governance.map((g) => `- **${g.entryId}** ${g.name} [${g.colle
         ...success(
           summaryText,
           { groundingReport, outcome: "suggest_only" },
-          [{ tool: "capture", description: "Capture for real", parameters: { collection: resolvedCollection, name, description } }]
+          // Fix 3 sibling (TEN-2918 follow-up): thread the caller's full original payload —
+          // see lib/captureForRealAction.ts's doc comment.
+          buildCaptureForRealNextAction({
+            collection: resolvedCollection,
+            name,
+            description,
+            context,
+            entryId,
+            canonicalKey,
+            data: userData,
+            links,
+            autoCommit,
+            sourceRef,
+            sourceExcerpt,
+            ownerTeamEntryId,
+            ownerRoleEntryId
+          })
         )
       }
     };
@@ -1607,7 +2214,7 @@ ${groundingReport.governance.map((g) => `- **${g.entryId}** ${g.name} [${g.colle
       // accepted shape as the CLI dying between create and re-eval).
       ...links && links.length > 0 ? { deferLLMSchedule: true } : {}
     });
-    if (result2 && "preview" in result2 && result2.preview) {
+    if (result2 && isPreviewCreateEntryResult(result2)) {
       const hasGrounding = groundingReport.related.length > 0 || groundingReport.duplicates.length > 0 || groundingReport.governance.length > 0;
       const groundingSummary = hasGrounding ? `
 
@@ -1623,7 +2230,10 @@ ${groundingReport.governance.map((g) => `- **${g.entryId}** ${g.name} [${g.colle
         {
           entryId: result2.entryId,
           name,
-          collection: resolvedCollection,
+          // P0 round 4 (fix 1/3, root): see resolveEffectiveCollection's doc comment
+          // (lib/createEntryPreviewResult.ts) for why this must be the server's EFFECTIVE
+          // post-routing collection, never the caller's pre-routing `resolvedCollection`.
+          collection: resolveEffectiveCollection(result2, preview, resolvedCollection),
           outcome: wouldBlock ? "blocked" : "preview",
           ...wouldBlock && result2.blockingReason ? { blockingReason: result2.blockingReason } : {},
           warnings: result2.warnings ?? [],
@@ -1631,7 +2241,26 @@ ${groundingReport.governance.map((g) => `- **${g.entryId}** ${g.name} [${g.colle
           // TEN-2458: thread task-alignment verdict when kernel computed it for this preview.
           ...result2.taskAlignment ? { taskAlignment: result2.taskAlignment } : {}
         },
-        [{ tool: "capture", description: "Capture for real", parameters: { collection: resolvedCollection, name, description } }]
+        // Fix 3 (WP-577 review re-review, TEN-2918 follow-up): thread the caller's full
+        // original payload so a follow-up "capture for real" creates the SAME entry the
+        // preview described — see lib/captureForRealAction.ts's doc comment for the bug
+        // this closes (a bare {collection,name,description} dropped `data`/`links`/etc.,
+        // so a required WHY supplied via `data` silently vanished on retry).
+        buildCaptureForRealNextAction({
+          collection: resolvedCollection,
+          name,
+          description,
+          context,
+          entryId,
+          canonicalKey,
+          data: userData,
+          links,
+          autoCommit,
+          sourceRef,
+          sourceExcerpt,
+          ownerTeamEntryId,
+          ownerRoleEntryId
+        })
       );
       if (result2.contract) {
         previewEnvelope.contract = result2.contract;
@@ -2294,6 +2923,7 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
     }
   }
   const results = [];
+  const previewDupTracker = createBatchPreviewDuplicateTracker();
   const skippedLowConfidence = [];
   await server.sendLoggingMessage({
     level: "info",
@@ -2328,20 +2958,15 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
         await pending.finish(scores);
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        results.push({
+        results.push(buildBatchEntryFailure({
           entryIdx: pending.entryIdx,
           name: pending.entry.name,
           collection: pending.resolvedSlug,
-          entryId: "",
-          ok: false,
-          autoLinks: 0,
-          advisedLinks: 0,
-          status: "draft",
           classifiedBy: pending.classifiedBy,
           confidence: pending.confidence,
           confidenceTier: pending.confidenceTier,
           error: msg
-        });
+        }));
       }
     }
   }
@@ -2388,38 +3013,28 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
     const profile = await getProfile(resolvedSlug);
     const col = collCache.get(resolvedSlug);
     if (!col) {
-      results.push({
+      results.push(buildBatchEntryFailure({
         entryIdx,
         name: entry.name,
         collection: resolvedSlug,
-        entryId: "",
-        ok: false,
-        autoLinks: 0,
-        advisedLinks: 0,
-        status: "draft",
         classifiedBy,
         confidence,
         confidenceTier,
         error: `Collection "${resolvedSlug}" not found`
-      });
+      }));
       continue;
     }
     if (entry.entryId && resolvedSlug !== "business-rules" && resolvedSlug !== "standards") {
-      results.push({
+      results.push(buildBatchEntryFailure({
         entryIdx,
         name: entry.name,
         collection: resolvedSlug,
-        entryId: "",
-        ok: false,
-        autoLinks: 0,
-        advisedLinks: 0,
-        status: "draft",
         classifiedBy,
         confidence,
         confidenceTier,
         // BR-111
         error: `entryId only allowed for business-rules and standards. Omit for ${resolvedSlug}.`
-      });
+      }));
       continue;
     }
     const data = buildDataFromFields(col.fields ?? [], profile.descriptionField, entry.description);
@@ -2484,8 +3099,22 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
       }
     }
     canonicalizeSelects(data, col.fields ?? [], batchIsBet);
+    const previewDuplicate = checkBatchPreviewDuplicate(previewDupTracker, {
+      preview,
+      entryIdx,
+      name: entry.name,
+      collection: resolvedSlug,
+      callerEntryId: entry.entryId,
+      classifiedBy,
+      confidence,
+      confidenceTier
+    });
+    if (previewDuplicate) {
+      results.push(previewDuplicate);
+      continue;
+    }
     try {
-      const result2 = await kernelMutation("chain.createEntry", {
+      const rawResult = await kernelMutation("chain.createEntry", {
         collectionSlug: resolvedSlug,
         entryId: entry.entryId ?? void 0,
         name: entry.name,
@@ -2503,13 +3132,30 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
         ...entry.ownerTeamEntryId ? { ownerTeamEntryId: entry.ownerTeamEntryId } : {},
         ...entry.ownerRoleEntryId ? { ownerRoleEntryId: entry.ownerRoleEntryId } : {}
       });
+      const previewWouldBlock = extractPreviewWouldBlock(rawResult, preview);
+      const effectiveCollection = resolveEffectiveCollection(rawResult, preview, resolvedSlug);
+      const result2 = rawResult;
+      const postRoutingDuplicate = reconcileBatchPreviewDuplicate(previewDupTracker, {
+        wouldCapture: Boolean(preview && previewWouldBlock && !previewWouldBlock.wouldBlock),
+        effectiveCollection,
+        entryIdx,
+        name: entry.name,
+        callerEntryId: entry.entryId,
+        classifiedBy,
+        confidence,
+        confidenceTier
+      });
+      if (postRoutingDuplicate) {
+        results.push(postRoutingDuplicate);
+        continue;
+      }
       const internalId = result2.docId;
       const finalEntryId = result2.entryId;
       const batchEntryWarnings = [
         ...batchDecomposeWarning ? [batchDecomposeWarning] : [],
         ...result2.warnings ?? []
       ];
-      resolveGapsForEntry(entry.name, result2.entryId);
+      if (!preview) resolveGapsForEntry(entry.name, result2.entryId);
       const batchWasAutoCommittedServerSide = result2.status === "active";
       let finalStatus = batchWasAutoCommittedServerSide ? "committed" : "draft";
       let commitError;
@@ -2595,47 +3241,22 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
             } catch {
             }
           }
-          let relationsCreatedCount = 0;
-          let relationsPreviewedCount = 0;
-          let relationsProposedCount = 0;
-          const relationsFailedList = [];
-          if (entry.relations && entry.relations.length > 0) {
-            for (const rel of entry.relations) {
-              try {
-                const relResult = await kernelMutation(
-                  "chain.createEntryRelation",
-                  {
-                    fromEntryId: finalEntryId,
-                    toEntryId: rel.to,
-                    type: rel.type,
-                    proposedBy: "user",
-                    sessionId: agentId ?? void 0,
-                    ...preview ? { preview: true } : {}
-                  }
-                );
-                if (relResult?.preview) {
-                  relationsPreviewedCount++;
-                } else if (relResult?.status === "agent_proposal_created") {
-                  relationsProposedCount++;
-                } else {
-                  relationsCreatedCount++;
-                }
-              } catch (relErr) {
-                const relMsg = relErr instanceof Error ? relErr.message : String(relErr);
-                relationsFailedList.push(`${rel.to} (${rel.type}): ${relMsg}`);
-              }
-            }
-            if (relationsFailedList.length > 0) {
-              batchEntryWarnings.push(`${relationsFailedList.length} inline relation(s) failed: ${relationsFailedList.join("; ")}`);
-            }
-            if (relationsPreviewedCount > 0) {
-              batchEntryWarnings.push(`${relationsPreviewedCount} inline relation(s) would be created (preview \u2014 no DB writes).`);
-            }
-            if (relationsProposedCount > 0) {
-              batchEntryWarnings.push(`${relationsProposedCount} inline relation(s) converted to an agent proposal (misuse pattern) \u2014 review in Cortex UI.`);
-            }
+          const {
+            relationsCreatedCount,
+            relationsProposedCount,
+            relationsNotValidatedCount,
+            relationsFailedList
+          } = await applyBatchInlineRelations(entry.relations, finalEntryId, preview, agentId);
+          if (relationsFailedList.length > 0) {
+            batchEntryWarnings.push(`${relationsFailedList.length} inline relation(s) failed: ${relationsFailedList.join("; ")}`);
+          }
+          if (relationsNotValidatedCount > 0) {
+            batchEntryWarnings.push(`${relationsNotValidatedCount} inline relation(s) not validated in preview (target existence and relation policy are checked at capture).`);
+          }
+          if (relationsProposedCount > 0) {
+            batchEntryWarnings.push(`${relationsProposedCount} inline relation(s) converted to an agent proposal (misuse pattern) \u2014 review in Cortex UI.`);
           }
-          if (autoCommitApplied && !batchWasAutoCommittedServerSide) {
+          if (!preview && autoCommitApplied && !batchWasAutoCommittedServerSide) {
             try {
               const semanticConflicts = await discoverSemanticConflicts(entry.name, entry.description, resolvedSlug);
               const commitResult = await kernelMutation("chain.commitEntry", {
@@ -2672,7 +3293,9 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
           results.push({
             entryIdx,
             name: entry.name,
-            collection: resolvedSlug,
+            // P0 round 4 (fix 1/3, root): EFFECTIVE (post-routing) collection — see
+            // `effectiveCollection`'s declaration above, ~2 screens up.
+            collection: effectiveCollection,
             entryId: finalEntryId,
             ok: true,
             autoLinks: autoLinkCount,
@@ -2681,6 +3304,11 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
             classifiedBy,
             confidence,
             confidenceTier,
+            ...previewWouldBlock ? { wouldBlock: previewWouldBlock.wouldBlock } : {},
+            ...previewWouldBlock?.blockingReason ? { blockingReason: previewWouldBlock.blockingReason } : {},
+            // Fix 1 (TEN-2918 follow-up): not caller-supplied — the preview projection
+            // must not report this predicted-but-duplicable ID as concrete.
+            ...!entry.entryId ? { entryIdAssignedAtCapture: true } : {},
             ...commitError ? { commitError } : {},
             // WP-465 surface parity: thread full refusal payload for coherency-refused batch entries.
             ...commitRefusal ? { commitRefusal } : {},
@@ -2705,20 +3333,15 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
       if (job) chunkBytes += prospectiveJobBytes;
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
-      results.push({
+      results.push(buildBatchEntryFailure({
         entryIdx,
         name: entry.name,
         collection: resolvedSlug,
-        entryId: "",
-        ok: false,
-        autoLinks: 0,
-        advisedLinks: 0,
-        status: "draft",
         classifiedBy,
         confidence,
         confidenceTier,
         error: msg
-      });
+      }));
     }
   }
   await flushPendingChunk(pendingFinish);
@@ -2734,6 +3357,9 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
     data: `Batch complete. ${created.length} succeeded, ${failed.length} failed, ${skippedLowConfidence.length} skipped (low confidence).`,
     logger: "product-brain"
   });
+  if (preview) {
+    return buildBatchPreviewFromResults(created, failed, skippedLowConfidence, entries.length, entries, autoCommit);
+  }
   const totalAutoLinks = created.reduce((sum, r) => sum + r.autoLinks, 0);
   const totalAdvisedLinks = created.reduce((sum, r) => sum + r.advisedLinks, 0);
   const byCollection = /* @__PURE__ */ new Map();
@@ -2992,92 +3618,6 @@ async function recordCommitFailure({
     }
   }
 }
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "the",
-  "and",
-  "for",
-  "are",
-  "but",
-  "not",
-  "you",
-  "all",
-  "can",
-  "has",
-  "her",
-  "was",
-  "one",
-  "our",
-  "out",
-  "day",
-  "had",
-  "hot",
-  "how",
-  "its",
-  "may",
-  "new",
-  "now",
-  "old",
-  "see",
-  "way",
-  "who",
-  "did",
-  "get",
-  "let",
-  "say",
-  "she",
-  "too",
-  "use",
-  "from",
-  "have",
-  "been",
-  "each",
-  "that",
-  "this",
-  "with",
-  "will",
-  "they",
-  "what",
-  "when",
-  "make",
-  "like",
-  "long",
-  "look",
-  "many",
-  "some",
-  "them",
-  "than",
-  "most",
-  "only",
-  "over",
-  "such",
-  "into",
-  "also",
-  "back",
-  "just",
-  "much",
-  "must",
-  "name",
-  "very",
-  "your",
-  "after",
-  "which",
-  "their",
-  "about",
-  "would",
-  "there",
-  "should",
-  "could",
-  "other",
-  "these",
-  "first",
-  "being",
-  "those",
-  "still",
-  "where"
-]);
-function tokenizeText(input) {
-  return input.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").split(/\s+/).filter(Boolean);
-}
 async function runContradictionCheck(name, description) {
   const warnings = [];
   try {
@@ -3131,91 +3671,6 @@ async function discoverSemanticConflicts(name, description, collectionHint) {
     return [];
   }
 }
-function verdictQualityPhrase(result2) {
-  const v = result2?.verdict;
-  const criteria = v?.criteria ?? [];
-  if (!v || criteria.length === 0) {
-    return "Quality: not evaluated (no rubric for this type).";
-  }
-  const total = criteria.length;
-  const passed = criteria.filter((c) => c.passed).length;
-  return v.passed ? `Quality: all ${total} rubric criteria pass.` : `Quality: ${passed}/${total} rubric criteria pass \u2014 see the coaching above.`;
-}
-function formatRubricCoaching(result2) {
-  const { verdict, rogerMartin } = result2;
-  if (!verdict || verdict.criteria.length === 0) return "";
-  const lines = ["## Semantic Quality"];
-  const failed = (verdict.criteria ?? []).filter((c) => !c.passed);
-  const total = verdict.criteria?.length ?? 0;
-  const passedCount = total - failed.length;
-  if (verdict.passed) {
-    lines.push(`All ${total} rubric criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier).`);
-  } else {
-    lines.push(`${passedCount}/${total} criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier)`);
-    lines.push("");
-    for (const c of verdict.criteria) {
-      const icon = c.passed ? "[x]" : "[ ]";
-      const extra = c.passed ? "" : ` \u2014 ${c.hint}`;
-      lines.push(`${icon} ${c.id}${extra}`);
-    }
-    if (verdict.weakest) {
-      lines.push("");
-      lines.push(`**Coaching hint:** ${verdict.weakest.hint}`);
-      lines.push(`_Question to consider:_ ${verdict.weakest.questionTemplate}`);
-    }
-  }
-  if (rogerMartin) {
-    lines.push("");
-    lines.push("### Roger Martin Test");
-    if (rogerMartin.isStrategicChoice) {
-      lines.push("This principle passes \u2014 the opposite is a reasonable strategic choice.");
-    } else {
-      lines.push(`This principle may not be a strategic choice. ${rogerMartin.reasoning}`);
-      if (rogerMartin.suggestion) {
-        lines.push(`_Suggestion:_ ${rogerMartin.suggestion}`);
-      }
-    }
-  }
-  return lines.join("\n");
-}
-function formatRubricVerdictSection(verdict) {
-  if (!verdict || !verdict.criteria || verdict.criteria.length === 0) return "";
-  const lines = ["## Semantic Quality"];
-  const failed = verdict.criteria.filter((c) => !c.passed);
-  const total = verdict.criteria.length;
-  const passedCount = total - failed.length;
-  const durationSuffix = verdict.llmDurationMs ? ` in ${(verdict.llmDurationMs / 1e3).toFixed(1)}s` : "";
-  const statusNote = verdict.llmStatus === "pending" ? " \u2014 LLM evaluation in progress..." : verdict.llmStatus === "failed" ? ` \u2014 LLM evaluation failed${verdict.llmError ? `: ${verdict.llmError}` : ""}, showing heuristic results` : verdict.source === "llm" && durationSuffix ? ` \u2014 evaluated${durationSuffix}` : "";
-  if (failed.length === 0) {
-    lines.push(`All ${total} rubric criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier, ${verdict.source} evaluation).${statusNote}`);
-  } else {
-    lines.push(`${passedCount}/${total} criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier, ${verdict.source} evaluation)${statusNote}`);
-    lines.push("");
-    for (const c of verdict.criteria) {
-      const icon = c.passed ? "[x]" : "[ ]";
-      const extra = c.passed ? "" : ` \u2014 ${c.hint}`;
-      lines.push(`${icon} ${c.id}${extra}`);
-    }
-    if (verdict.weakest) {
-      lines.push("");
-      lines.push(`**Top improvement:** ${verdict.weakest.hint}`);
-    }
-  }
-  if (verdict.rogerMartin) {
-    const rm = verdict.rogerMartin;
-    lines.push("");
-    lines.push("### Roger Martin Test");
-    if (rm.isStrategicChoice) {
-      lines.push(`This is a real strategic choice \u2014 the opposite is reasonable. ${rm.reasoning}`);
-    } else {
-      lines.push(`This may not be a strategic choice. ${rm.reasoning}`);
-      if (rm.suggestion) {
-        lines.push(`_Suggestion:_ ${rm.suggestion}`);
-      }
-    }
-  }
-  return lines.join("\n");
-}
 
 // src/tools/conflict-preflight.ts
 async function runConflictPreflight(name, description, collectionHint) {
@@ -3271,44 +3726,44 @@ var WORKFLOW_STATUS_VALUES = [
   "evidenced"
 ];
 var LEGACY_WORKFLOW_STATUSES = new Set(WORKFLOW_STATUS_VALUES);
-var updateEntrySchema = z3.object({
-  entryId: z3.string().describe("Entry ID to update, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'"),
-  name: z3.string().optional().describe("New display name"),
-  status: z3.union([
-    z3.enum(["draft", "active", "deprecated", "archived"]),
+var updateEntrySchema = z5.object({
+  entryId: z5.string().describe("Entry ID to update, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'"),
+  name: z5.string().optional().describe("New display name"),
+  status: z5.union([
+    z5.enum(["draft", "active", "deprecated", "archived"]),
     // BET-68 legacy shim: frozen historical workflow values still pass through
     // `status` (auto-routed with a warning) until the ~2026-09-03 sunset.
-    z3.enum(WORKFLOW_STATUS_VALUES)
+    z5.enum(WORKFLOW_STATUS_VALUES)
   ]).optional().describe("Lifecycle status: draft | active | deprecated | archived. **Workflow values are deprecated here \u2014 use `workflowStatus` instead. Passing a workflow value as `status` will be auto-routed with a warning until 2026-09-03, then hard-errored.**"),
-  workflowStatus: z3.string().optional().describe("Collection workflow state. Valid values are collection-specific and server-owned \u2014 discover them via `collections action=describe` for the target collection. The server rejects invalid values and returns the valid set in the error."),
-  data: z3.record(z3.unknown()).optional().describe("Fields to update (merged with existing data)"),
-  order: z3.number().optional().describe("New sort order"),
-  canonicalKey: z3.string().optional().describe("Semantic type (e.g. 'decision', 'tension'). Only changeable on draft/uncommitted entries."),
-  autoPublish: z3.boolean().optional().default(false).describe("Only true when user explicitly asks to publish. Default false = draft. Never auto-publish without user confirmation."),
-  changeNote: z3.string().optional().describe("Strongly recommended: short human-readable rationale for WHY this change was made (e.g. 'Aligned description with F1-themed copy'). Surfaces in activity feed and pb get. If omitted, falls back to session purpose or auto-generated field summary."),
-  sourceRef: z3.string().optional().describe("URI or path of the source document backing this entry. Write-once: can only be set if currently empty."),
-  sourceExcerpt: z3.string().optional().describe("Verbatim excerpt from the source that backs this entry's claims. Write-once: can only be set if currently empty."),
+  workflowStatus: z5.string().optional().describe("Collection workflow state. Valid values are collection-specific and server-owned \u2014 discover them via `collections action=describe` for the target collection. The server rejects invalid values and returns the valid set in the error."),
+  data: z5.record(z5.unknown()).optional().describe("Fields to update (merged with existing data)"),
+  order: z5.number().optional().describe("New sort order"),
+  canonicalKey: z5.string().optional().describe("Semantic type (e.g. 'decision', 'tension'). Only changeable on draft/uncommitted entries."),
+  autoPublish: z5.boolean().optional().default(false).describe("Only true when user explicitly asks to publish. Default false = draft. Never auto-publish without user confirmation."),
+  changeNote: z5.string().optional().describe("Strongly recommended: short human-readable rationale for WHY this change was made (e.g. 'Aligned description with F1-themed copy'). Surfaces in activity feed and pb get. If omitted, falls back to session purpose or auto-generated field summary."),
+  sourceRef: z5.string().optional().describe("URI or path of the source document backing this entry. Write-once: can only be set if currently empty."),
+  sourceExcerpt: z5.string().optional().describe("Verbatim excerpt from the source that backs this entry's claims. Write-once: can only be set if currently empty."),
   // WP-465 slice ⑤ — relay-only (TEN-2233): validation/min-length/recording live in Convex.
-  steeringOverrideReason: z3.string().optional().describe("Typed override (\u226512 chars) that clears a steering coherency block on a misaligned governance write \u2014 always recorded with author attribution."),
-  coherencyAcknowledgement: z3.object({
-    response: z3.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
-    entryId: z3.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
-    reason: z3.string().optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
+  steeringOverrideReason: z5.string().optional().describe("Typed override (\u226512 chars) that clears a steering coherency block on a misaligned governance write \u2014 always recorded with author attribution."),
+  coherencyAcknowledgement: z5.object({
+    response: z5.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
+    entryId: z5.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
+    reason: z5.string().optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
   }).optional().describe("Explicit response to a coherency challenge (standard/strict workspace modes). One acknowledgement per challenge per entry per session.")
 });
-var getHistorySchema = z3.object({
-  entryId: z3.string().describe("Entry ID, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'")
+var getHistorySchema = z5.object({
+  entryId: z5.string().describe("Entry ID, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'")
 });
-var commitEntrySchema = z3.object({
-  entryId: z3.string().describe("Entry ID to accept, e.g. 'TEN-abc123', '<PREFIX>-<n>'"),
+var commitEntrySchema = z5.object({
+  entryId: z5.string().describe("Entry ID to accept, e.g. 'TEN-abc123', '<PREFIX>-<n>'"),
   // WP-316 S3: Preview gate — dry-run mode. Returns would-succeed result, no DB writes.
-  preview: z3.boolean().optional().describe("If true, validates the accept without writing. Returns what would happen. Default false."),
+  preview: z5.boolean().optional().describe("If true, validates the accept without writing. Returns what would happen. Default false."),
   // WP-465 slice ⑤ — relay-only (TEN-2233): validation/recording live in Convex.
-  steeringOverrideReason: z3.string().optional().describe("Typed override (\u226512 chars) that clears a steering coherency block at the publish chokepoint \u2014 always recorded with author attribution."),
-  coherencyAcknowledgement: z3.object({
-    response: z3.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
-    entryId: z3.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
-    reason: z3.string().optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
+  steeringOverrideReason: z5.string().optional().describe("Typed override (\u226512 chars) that clears a steering coherency block at the publish chokepoint \u2014 always recorded with author attribution."),
+  coherencyAcknowledgement: z5.object({
+    response: z5.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
+    entryId: z5.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
+    reason: z5.string().optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
   }).optional().describe("Explicit response to a coherency challenge (standard/strict workspace modes).")
 });
 async function handleUpdateEntry({ entryId, name, status: rawStatus, workflowStatus: rawWorkflowStatus, data, order, canonicalKey, autoPublish, changeNote, sourceRef, sourceExcerpt, steeringOverrideReason, coherencyAcknowledgement }, toolName = "entries") {
@@ -3713,7 +4168,7 @@ No DB writes \u2014 call without \`preview:true\` to accept for real.` }],
 // src/tools/verify.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
 import { resolve as resolve2 } from "path";
-import { z as z4 } from "zod/v3";
+import { z as z6 } from "zod/v3";
 
 // src/lib/resolve-project-root.ts
 import { existsSync } from "fs";
@@ -3865,12 +4320,12 @@ function formatTrustReport(collection, entryCount, mappings, refs, fixes, mode,
   lines.push("", "---", `_Schema: ${schemaTableCount} tables parsed from convex/schema.ts. Project root: ${projectRoot}_`);
   return lines.join("\n");
 }
-var verifySchema = z4.object({
-  collection: z4.string().max(200).default("glossary").describe("Collection slug to verify (default: glossary)"),
-  mode: z4.enum(["report", "fix"]).default("report").describe("'report' = read-only trust report. 'fix' = also update drifted codeMapping statuses.")
+var verifySchema = z6.object({
+  collection: z6.string().max(200).default("glossary").describe("Collection slug to verify (default: glossary)"),
+  mode: z6.enum(["report", "fix"]).default("report").describe("'report' = read-only trust report. 'fix' = also update drifted codeMapping statuses.")
 });
-var verifyEntrySchema = z4.object({
-  entryId: z4.string().max(200).describe("Human entry ID (e.g. '<PREFIX>-<n>') to mark as verified")
+var verifyEntrySchema = z6.object({
+  entryId: z6.string().max(200).describe("Human entry ID (e.g. '<PREFIX>-<n>') to mark as verified")
 });
 async function handleVerifyChain(server, { collection, mode }) {
   const projectRoot = resolveProjectRoot();
@@ -4087,10 +4542,10 @@ async function handleVerifyEntry({ entryId }) {
 }
 
 // src/tools/entry-move.ts
-import { z as z5 } from "zod/v3";
-var moveEntrySchema = z5.object({
-  entryId: z5.string().describe("Entry ID to move, e.g. '<PREFIX>-<n>'"),
-  toCollection: z5.string().describe("Target collection slug, e.g. 'decisions', 'architecture'")
+import { z as z7 } from "zod/v3";
+var moveEntrySchema = z7.object({
+  entryId: z7.string().describe("Entry ID to move, e.g. '<PREFIX>-<n>'"),
+  toCollection: z7.string().describe("Target collection slug, e.g. 'decisions', 'architecture'")
 });
 async function handleMoveEntry(entryId, toCollection) {
   try {
@@ -4201,89 +4656,89 @@ var ENTRIES_ACTIONS = [
   "move",
   "verify"
 ];
-var coherencyAcknowledgementFlatSchema = z6.object({
-  response: z6.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
-  entryId: z6.string().max(200).optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
-  reason: z6.string().max(2e3).optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
+var coherencyAcknowledgementFlatSchema = z8.object({
+  response: z8.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
+  entryId: z8.string().max(200).optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
+  reason: z8.string().max(2e3).optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
 });
-var entriesSchema = z6.object({
-  action: z6.enum(ENTRIES_ACTIONS).describe(
+var entriesSchema = z8.object({
+  action: z8.enum(ENTRIES_ACTIONS).describe(
     "'list': browse entries with filters. 'get': fetch one entry by ID. 'batch': fetch multiple entries. 'search': full-text search. 'update': change fields on an existing entry (draft by default). 'commit': accept a draft entry onto the Chain. 'history': audit trail for an entry. 'move': reclassify an entry to a different collection. 'verify': mark an entry as verified (lightweight \u2014 no codebase scan; see `quality action=verify-chain` for the codebase-scanning check)."
   ),
-  entryId: z6.string().max(200).optional().describe(
+  entryId: z8.string().max(200).optional().describe(
     "Entry ID, e.g. '<PREFIX>-<n>'. Required for: get, update, commit, history, move, verify."
   ),
-  entryIds: z6.array(z6.string().max(200)).min(1).max(20).optional().describe("Entry IDs for 'batch', e.g. ['TYPE-strategy', 'STR-jljeg7']"),
-  collection: z6.string().max(200).optional().describe("Collection slug \u2014 for 'list'/'search': scope filter, e.g. 'glossary', 'tracking-events'."),
-  status: z6.string().max(200).optional().describe(
+  entryIds: z8.array(z8.string().max(200)).min(1).max(20).optional().describe("Entry IDs for 'batch', e.g. ['TYPE-strategy', 'STR-jljeg7']"),
+  collection: z8.string().max(200).optional().describe("Collection slug \u2014 for 'list'/'search': scope filter, e.g. 'glossary', 'tracking-events'."),
+  status: z8.string().max(200).optional().describe(
     "For 'list'/'search': filter string (draft | active | deprecated | archived). For 'update': lifecycle value to set (draft | active | deprecated | archived \u2014 legacy workflow values still route through here with a deprecation warning until 2026-09-03; use `workflowStatus` instead)."
   ),
-  tag: z6.string().max(200).optional().describe("For 'list': filter by internal tag."),
-  label: z6.string().max(200).optional().describe("For 'list': filter by label slug \u2014 matches entries across all collections."),
-  query: z6.string().min(2).max(500).optional().describe("For 'search': search text (min 2 characters)."),
-  name: z6.string().max(500).optional().describe("For 'update': new display name."),
-  workflowStatus: z6.string().max(200).optional().describe(
+  tag: z8.string().max(200).optional().describe("For 'list': filter by internal tag."),
+  label: z8.string().max(200).optional().describe("For 'list': filter by label slug \u2014 matches entries across all collections."),
+  query: z8.string().min(2).max(500).optional().describe("For 'search': search text (min 2 characters)."),
+  name: z8.string().max(500).optional().describe("For 'update': new display name."),
+  workflowStatus: z8.string().max(200).optional().describe(
     "For 'update': collection workflow state. Valid values are collection-specific and server-owned \u2014 discover via `collections action=describe`. Invalid values are rejected with the valid set."
   ),
-  data: z6.record(z6.unknown()).optional().describe("For 'update': fields to update (merged with existing data)."),
-  order: z6.number().optional().describe("For 'update': new sort order."),
-  canonicalKey: z6.string().max(200).optional().describe(
+  data: z8.record(z8.unknown()).optional().describe("For 'update': fields to update (merged with existing data)."),
+  order: z8.number().optional().describe("For 'update': new sort order."),
+  canonicalKey: z8.string().max(200).optional().describe(
     "For 'update': semantic type (e.g. 'decision', 'tension'). Only changeable on draft/uncommitted entries."
   ),
-  autoPublish: z6.boolean().optional().default(false).describe(
+  autoPublish: z8.boolean().optional().default(false).describe(
     "For 'update': only true when the user explicitly asks to publish. Default false = draft."
   ),
-  changeNote: z6.string().max(2e3).optional().describe(
+  changeNote: z8.string().max(2e3).optional().describe(
     "For 'update': short human-readable rationale for WHY this change was made. Surfaces in activity feed."
   ),
-  sourceRef: z6.string().max(2e3).optional().describe(
+  sourceRef: z8.string().max(2e3).optional().describe(
     "For 'update': URI or path of the source document backing this entry. Write-once."
   ),
-  sourceExcerpt: z6.string().max(5e3).optional().describe(
+  sourceExcerpt: z8.string().max(5e3).optional().describe(
     "For 'update': verbatim excerpt from the source backing this entry's claims. Write-once."
   ),
-  steeringOverrideReason: z6.string().max(2e3).optional().describe(
+  steeringOverrideReason: z8.string().max(2e3).optional().describe(
     "For 'update'/'commit': typed override (\u226512 chars) that clears a steering coherency block."
   ),
   coherencyAcknowledgement: coherencyAcknowledgementFlatSchema.optional().describe(
     "For 'update'/'commit': explicit response to a coherency challenge (standard/strict workspace modes)."
   ),
-  preview: z6.boolean().optional().describe(
+  preview: z8.boolean().optional().describe(
     "For 'commit': if true, validates the accept without writing \u2014 returns what would happen."
   ),
-  toCollection: z6.string().max(200).optional().describe("For 'move': target collection slug, e.g. 'decisions', 'architecture'.")
+  toCollection: z8.string().max(200).optional().describe("For 'move': target collection slug, e.g. 'decisions', 'architecture'.")
 });
-var entriesListVariant = z6.object({
-  action: z6.literal("list"),
-  collection: z6.string().max(200).optional(),
-  status: z6.string().max(200).optional(),
-  tag: z6.string().max(200).optional(),
-  label: z6.string().max(200).optional()
+var entriesListVariant = z8.object({
+  action: z8.literal("list"),
+  collection: z8.string().max(200).optional(),
+  status: z8.string().max(200).optional(),
+  tag: z8.string().max(200).optional(),
+  label: z8.string().max(200).optional()
 });
-var entriesGetVariant = z6.object({
-  action: z6.literal("get"),
-  entryId: z6.string().max(200)
+var entriesGetVariant = z8.object({
+  action: z8.literal("get"),
+  entryId: z8.string().max(200)
 });
-var entriesBatchVariant = z6.object({
-  action: z6.literal("batch"),
-  entryIds: z6.array(z6.string().max(200)).min(1).max(20)
+var entriesBatchVariant = z8.object({
+  action: z8.literal("batch"),
+  entryIds: z8.array(z8.string().max(200)).min(1).max(20)
 });
-var entriesSearchVariant = z6.object({
-  action: z6.literal("search"),
-  query: z6.string().min(2).max(500),
-  collection: z6.string().max(200).optional(),
-  status: z6.string().max(200).optional()
+var entriesSearchVariant = z8.object({
+  action: z8.literal("search"),
+  query: z8.string().min(2).max(500),
+  collection: z8.string().max(200).optional(),
+  status: z8.string().max(200).optional()
 });
-var entriesUpdateVariant = updateEntrySchema.extend({ action: z6.literal("update") });
-var entriesCommitVariant = commitEntrySchema.extend({ action: z6.literal("commit") });
-var entriesHistoryVariant = getHistorySchema.extend({ action: z6.literal("history") });
-var entriesMoveVariant = z6.object({
-  action: z6.literal("move"),
-  entryId: z6.string().max(200),
-  toCollection: z6.string().max(200)
+var entriesUpdateVariant = updateEntrySchema.extend({ action: z8.literal("update") });
+var entriesCommitVariant = commitEntrySchema.extend({ action: z8.literal("commit") });
+var entriesHistoryVariant = getHistorySchema.extend({ action: z8.literal("history") });
+var entriesMoveVariant = z8.object({
+  action: z8.literal("move"),
+  entryId: z8.string().max(200),
+  toCollection: z8.string().max(200)
 });
-var entriesVerifyVariant = verifyEntrySchema.extend({ action: z6.literal("verify") });
-var entriesActionUnion = z6.discriminatedUnion("action", [
+var entriesVerifyVariant = verifyEntrySchema.extend({ action: z8.literal("verify") });
+var entriesActionUnion = z8.discriminatedUnion("action", [
   entriesListVariant,
   entriesGetVariant,
   entriesBatchVariant,
@@ -4305,15 +4760,15 @@ var ENTRIES_ACTION_SPECS = {
   move: { params: ["entryId", "toCollection"], description: "Both entryId and toCollection are required." },
   verify: { params: ["entryId"], description: "entryId is required." }
 };
-var entriesGetOutputSchema = z6.object({
-  entryId: z6.string(),
-  name: z6.string(),
-  collection: z6.string(),
-  status: z6.string(),
-  capturedAt: z6.number().optional(),
-  origin: z6.string().optional(),
-  originDetail: z6.string().optional(),
-  verificationStatus: z6.string().optional(),
+var entriesGetOutputSchema = z8.object({
+  entryId: z8.string(),
+  name: z8.string(),
+  collection: z8.string(),
+  status: z8.string(),
+  capturedAt: z8.number().optional(),
+  origin: z8.string().optional(),
+  originDetail: z8.string().optional(),
+  verificationStatus: z8.string().optional(),
   // Attestation-model finding (PR #341 review): the server's honest verifier label and
   // derived attestation strength/basis — connectors NEVER re-derive strength (spec §5),
   // they only render what chain.getEntry ships. Mirrors packages/cli EntryFromApi.
@@ -4322,72 +4777,72 @@ var entriesGetOutputSchema = z6.object({
   // attestation.ts's AttestationStrength SSOT (allowlisted in Check D —
   // scripts/check-collection-ssot.mjs's CHECK_D_ALLOWLIST — with the full
   // reasoning for why this can't just import that module). Update both together.
-  verifiedBy: z6.string().optional(),
-  attestation: z6.object({
-    strength: z6.enum(["human-direct", "delegated", "system", "unattested"]),
-    basis: z6.string().optional()
+  verifiedBy: z8.string().optional(),
+  attestation: z8.object({
+    strength: z8.enum(["human-direct", "delegated", "system", "unattested"]),
+    basis: z8.string().optional()
   }).optional(),
-  sourceRef: z6.string().optional(),
-  sourceExcerpt: z6.string().optional(),
-  why: z6.string().optional(),
+  sourceRef: z8.string().optional(),
+  sourceExcerpt: z8.string().optional(),
+  why: z8.string().optional(),
   // TEN-2191: quality of the captured WHY — 'rationale' | 'missing' | 'restated'.
-  whyQuality: z6.enum(["rationale", "missing", "restated"]).optional(),
-  data: z6.record(z6.unknown()).optional(),
-  relations: z6.array(z6.object({
-    entryId: z6.string().optional(),
-    name: z6.string(),
-    type: z6.string(),
-    direction: z6.string()
+  whyQuality: z8.enum(["rationale", "missing", "restated"]).optional(),
+  data: z8.record(z8.unknown()).optional(),
+  relations: z8.array(z8.object({
+    entryId: z8.string().optional(),
+    name: z8.string(),
+    type: z8.string(),
+    direction: z8.string()
   })).optional(),
-  labels: z6.array(z6.string()).optional()
+  labels: z8.array(z8.string()).optional()
 }).passthrough();
-var entriesListOutputSchema = z6.object({
-  entries: z6.array(z6.object({
-    entryId: z6.string(),
-    name: z6.string(),
-    collection: z6.string(),
-    status: z6.string()
+var entriesListOutputSchema = z8.object({
+  entries: z8.array(z8.object({
+    entryId: z8.string(),
+    name: z8.string(),
+    collection: z8.string(),
+    status: z8.string()
   })),
-  total: z6.number()
+  total: z8.number()
 });
-var entriesSearchOutputSchema = z6.object({
-  results: z6.array(z6.object({
-    entryId: z6.string(),
-    name: z6.string(),
-    collection: z6.string(),
-    status: z6.string(),
-    score: z6.number().optional()
+var entriesSearchOutputSchema = z8.object({
+  results: z8.array(z8.object({
+    entryId: z8.string(),
+    name: z8.string(),
+    collection: z8.string(),
+    status: z8.string(),
+    score: z8.number().optional()
   })),
-  total: z6.number(),
-  query: z6.string()
+  total: z8.number(),
+  query: z8.string()
 });
-var entriesBatchOutputSchema = z6.object({
-  entries: z6.array(z6.object({
-    entryId: z6.string(),
-    name: z6.string(),
-    collection: z6.string(),
-    status: z6.string(),
-    capturedAt: z6.number().optional(),
-    origin: z6.string().optional(),
-    originDetail: z6.string().optional(),
-    verificationStatus: z6.string().optional(),
+var entriesBatchOutputSchema = z8.object({
+  entries: z8.array(z8.object({
+    entryId: z8.string(),
+    name: z8.string(),
+    collection: z8.string(),
+    status: z8.string(),
+    capturedAt: z8.number().optional(),
+    origin: z8.string().optional(),
+    originDetail: z8.string().optional(),
+    verificationStatus: z8.string().optional(),
     // Attestation-model finding (PR #341 review): mirror entriesGetOutputSchema — batch
     // entries now carry the same honest verifiedBy/attestation fields. Literal set is
     // the same hand-kept SSOT mirror — see entriesGetOutputSchema's attestation
     // comment above for the full Check D / kernel-import reasoning.
-    verifiedBy: z6.string().optional(),
-    attestation: z6.object({
-      strength: z6.enum(["human-direct", "delegated", "system", "unattested"]),
-      basis: z6.string().optional()
+    verifiedBy: z8.string().optional(),
+    attestation: z8.object({
+      strength: z8.enum(["human-direct", "delegated", "system", "unattested"]),
+      basis: z8.string().optional()
     }).optional(),
-    sourceRef: z6.string().optional(),
-    sourceExcerpt: z6.string().optional(),
+    sourceRef: z8.string().optional(),
+    sourceExcerpt: z8.string().optional(),
     // TEN-2191: mirror entriesGetOutputSchema — batch entries now carry why/whyQuality.
-    why: z6.string().optional(),
-    whyQuality: z6.enum(["rationale", "missing", "restated"]).optional(),
-    data: z6.record(z6.unknown()).optional()
+    why: z8.string().optional(),
+    whyQuality: z8.enum(["rationale", "missing", "restated"]).optional(),
+    data: z8.record(z8.unknown()).optional()
   }).passthrough()),
-  total: z6.number()
+  total: z8.number()
 });
 function registerEntriesTools(server) {
   const entriesHandlers = {
@@ -4779,41 +5234,41 @@ ${footer}` }],
 }
 
 // src/tools/relations.ts
-import { z as z8 } from "zod/v3";
+import { z as z10 } from "zod/v3";
 
 // src/tools/graph.ts
-import { z as z7 } from "zod/v3";
+import { z as z9 } from "zod/v3";
 var GRAPH_ACTIONS = ["find", "suggest"];
-var graphSchema = z7.object({
-  action: z7.enum(GRAPH_ACTIONS).describe(
+var graphSchema = z9.object({
+  action: z9.enum(GRAPH_ACTIONS).describe(
     "'find': traverse relations from an entry (graph walk). 'suggest': discover potential connections for an entry."
   ),
-  entryId: z7.string().max(200).describe("Entry ID, e.g. '<PREFIX>-<n>'"),
-  direction: z7.enum(["incoming", "outgoing", "both"]).default("both").optional().describe("For find: 'incoming' = what references this, 'outgoing' = what this references"),
-  limit: z7.number().min(1).max(20).default(10).optional().describe("For suggest: max suggestions to return"),
-  depth: z7.number().min(1).max(3).default(2).optional().describe("For suggest: graph traversal depth")
+  entryId: z9.string().max(200).describe("Entry ID, e.g. '<PREFIX>-<n>'"),
+  direction: z9.enum(["incoming", "outgoing", "both"]).default("both").optional().describe("For find: 'incoming' = what references this, 'outgoing' = what this references"),
+  limit: z9.number().min(1).max(20).default(10).optional().describe("For suggest: max suggestions to return"),
+  depth: z9.number().min(1).max(3).default(2).optional().describe("For suggest: graph traversal depth")
 });
-var graphFindOutputSchema = z7.object({
-  entryId: z7.string(),
-  relations: z7.array(z7.object({
-    entryId: z7.string().optional(),
-    name: z7.string(),
-    type: z7.string(),
-    direction: z7.enum(["outgoing", "incoming"])
+var graphFindOutputSchema = z9.object({
+  entryId: z9.string(),
+  relations: z9.array(z9.object({
+    entryId: z9.string().optional(),
+    name: z9.string(),
+    type: z9.string(),
+    direction: z9.enum(["outgoing", "incoming"])
   })),
-  total: z7.number()
+  total: z9.number()
 });
-var graphSuggestOutputSchema = z7.object({
-  entryId: z7.string(),
-  suggestions: z7.array(z7.object({
-    targetEntryId: z7.string().optional(),
-    targetName: z7.string(),
-    relationType: z7.string(),
-    direction: z7.string(),
-    confidence: z7.number(),
-    reason: z7.string()
+var graphSuggestOutputSchema = z9.object({
+  entryId: z9.string(),
+  suggestions: z9.array(z9.object({
+    targetEntryId: z9.string().optional(),
+    targetName: z9.string(),
+    relationType: z9.string(),
+    direction: z9.string(),
+    confidence: z9.number(),
+    reason: z9.string()
   })),
-  total: z7.number()
+  total: z9.number()
 });
 async function handleFind(entryId, direction) {
   const relations = await kernelQuery("chain.listEntryRelations", { entryId });
@@ -5004,64 +5459,64 @@ async function handleSuggest(entryId, limit, depth) {
 
 // src/tools/relations.ts
 var RELATIONS_ACTIONS = ["create", "batch-create", "dismiss", "delete", "find", "suggest"];
-var relationItemSchema = z8.object({
-  from: z8.string().max(200),
-  to: z8.string().max(200),
-  type: z8.string().max(200)
+var relationItemSchema = z10.object({
+  from: z10.string().max(200),
+  to: z10.string().max(200),
+  type: z10.string().max(200)
 });
-var relationsSchema = z8.object({
-  action: z8.enum(RELATIONS_ACTIONS).describe(
+var relationsSchema = z10.object({
+  action: z10.enum(RELATIONS_ACTIONS).describe(
     "'create': link two entries. 'batch-create': create multiple relations (validates every item before writing any). 'dismiss': record that a suggestion was not relevant. 'delete': remove a relation. 'find': traverse relations from an entry (graph walk, absorbs graph action=find). 'suggest': discover potential connections for an entry (absorbs graph action=suggest)."
   ),
-  from: z8.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': source entry ID."),
-  to: z8.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': target entry ID."),
-  type: z8.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': relation type."),
-  score: z8.number().optional().describe("For 'dismiss': suggestion score from action=suggest."),
-  relations: z8.array(relationItemSchema).min(1).max(20).optional().describe("For 'batch-create': array of {from, to, type}."),
+  from: z10.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': source entry ID."),
+  to: z10.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': target entry ID."),
+  type: z10.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': relation type."),
+  score: z10.number().optional().describe("For 'dismiss': suggestion score from action=suggest."),
+  relations: z10.array(relationItemSchema).min(1).max(20).optional().describe("For 'batch-create': array of {from, to, type}."),
   // WP-316 S3: Preview gate — dry-run mode for action=create.
-  preview: z8.boolean().optional().describe("For 'create': if true, validates the relation without writing. Returns what would happen. Default false."),
-  entryId: z8.string().max(200).optional().describe("For 'find'/'suggest': entry ID, e.g. '<PREFIX>-<n>'."),
-  direction: z8.enum(["incoming", "outgoing", "both"]).optional().describe("For 'find': 'incoming' = what references this, 'outgoing' = what this references. Default 'both'."),
-  limit: z8.number().min(1).max(20).optional().describe("For 'suggest': max suggestions to return. Default 10."),
-  depth: z8.number().min(1).max(3).optional().describe("For 'suggest': graph traversal depth. Default 2.")
+  preview: z10.boolean().optional().describe("For 'create': if true, validates the relation without writing. Returns what would happen. Default false."),
+  entryId: z10.string().max(200).optional().describe("For 'find'/'suggest': entry ID, e.g. '<PREFIX>-<n>'."),
+  direction: z10.enum(["incoming", "outgoing", "both"]).optional().describe("For 'find': 'incoming' = what references this, 'outgoing' = what this references. Default 'both'."),
+  limit: z10.number().min(1).max(20).optional().describe("For 'suggest': max suggestions to return. Default 10."),
+  depth: z10.number().min(1).max(3).optional().describe("For 'suggest': graph traversal depth. Default 2.")
 });
-var relationsCreateVariant = z8.object({
-  action: z8.literal("create"),
-  from: z8.string().max(200),
-  to: z8.string().max(200),
-  type: z8.string().max(200),
-  score: z8.number().optional(),
-  preview: z8.boolean().optional()
+var relationsCreateVariant = z10.object({
+  action: z10.literal("create"),
+  from: z10.string().max(200),
+  to: z10.string().max(200),
+  type: z10.string().max(200),
+  score: z10.number().optional(),
+  preview: z10.boolean().optional()
 });
-var relationsBatchCreateVariant = z8.object({
-  action: z8.literal("batch-create"),
-  relations: z8.array(relationItemSchema).min(1).max(20)
+var relationsBatchCreateVariant = z10.object({
+  action: z10.literal("batch-create"),
+  relations: z10.array(relationItemSchema).min(1).max(20)
 });
-var relationsDismissVariant = z8.object({
-  action: z8.literal("dismiss"),
-  from: z8.string().max(200),
-  to: z8.string().max(200),
-  type: z8.string().max(200).optional(),
-  score: z8.number().optional()
+var relationsDismissVariant = z10.object({
+  action: z10.literal("dismiss"),
+  from: z10.string().max(200),
+  to: z10.string().max(200),
+  type: z10.string().max(200).optional(),
+  score: z10.number().optional()
 });
-var relationsDeleteVariant = z8.object({
-  action: z8.literal("delete"),
-  from: z8.string().max(200),
-  to: z8.string().max(200),
-  type: z8.string().max(200)
+var relationsDeleteVariant = z10.object({
+  action: z10.literal("delete"),
+  from: z10.string().max(200),
+  to: z10.string().max(200),
+  type: z10.string().max(200)
 });
-var relationsFindVariant = z8.object({
-  action: z8.literal("find"),
-  entryId: z8.string().max(200),
-  direction: z8.enum(["incoming", "outgoing", "both"]).optional().default("both")
+var relationsFindVariant = z10.object({
+  action: z10.literal("find"),
+  entryId: z10.string().max(200),
+  direction: z10.enum(["incoming", "outgoing", "both"]).optional().default("both")
 });
-var relationsSuggestVariant = z8.object({
-  action: z8.literal("suggest"),
-  entryId: z8.string().max(200),
-  limit: z8.number().min(1).max(20).optional().default(10),
-  depth: z8.number().min(1).max(3).optional().default(2)
+var relationsSuggestVariant = z10.object({
+  action: z10.literal("suggest"),
+  entryId: z10.string().max(200),
+  limit: z10.number().min(1).max(20).optional().default(10),
+  depth: z10.number().min(1).max(3).optional().default(2)
 });
-var relationsActionUnion = z8.discriminatedUnion("action", [
+var relationsActionUnion = z10.discriminatedUnion("action", [
   relationsCreateVariant,
   relationsBatchCreateVariant,
   relationsDismissVariant,
@@ -5345,19 +5800,19 @@ async function handleDelete(from, to, type) {
 }
 
 // src/tools/context.ts
-import { z as z10 } from "zod/v3";
+import { z as z12 } from "zod/v3";
 
 // src/tools/documents.ts
-import { z as z9 } from "zod/v3";
+import { z as z11 } from "zod/v3";
 var DOCUMENTS_ACTIONS = ["get-last-verified-brief"];
-var documentsSchema = z9.object({
-  action: z9.enum(DOCUMENTS_ACTIONS).describe(
+var documentsSchema = z11.object({
+  action: z11.enum(DOCUMENTS_ACTIONS).describe(
     "'get-last-verified-brief': fetch the most recent verified brief snapshot for a (templateId, scopeKey) pair. Returns the verified summary so agents can build delta narratives ('since you last verified, X workstreams advanced')."
   ),
-  templateId: z9.string().max(200).describe(
+  templateId: z11.string().max(200).describe(
     "Brief template identifier \u2014 currently 'steering-brief' is the only registered template."
   ),
-  scopeKey: z9.string().max(200).describe(
+  scopeKey: z11.string().max(200).describe(
     "Canonical scope key. Use 'workspace:<workspaceId>' for the full workspace brief, or 'initiative:<INI-ID>' for an initiative-scoped brief. The same formula is applied at write time (chainwork/docKernel/scopeKey.ts), so passing the wrong shape returns exists:false."
   )
 });
@@ -5437,89 +5892,89 @@ function epistemicCollectionHint(collectionName) {
   return "";
 }
 var CONTEXT_ACTIONS = ["gather", "build", "neighborhood", "changes", "chain", "cross-cut", "incremental", "brief", "last-verified-brief"];
-var contextSchema = z10.object({
+var contextSchema = z12.object({
   // provenance: neighborhood BET-142; changes/chain/cross-cut/incremental/brief BET-239 (E4, E6)
-  action: z10.enum(CONTEXT_ACTIONS).describe(
+  action: z12.enum(CONTEXT_ACTIONS).describe(
     "'gather': assemble knowledge context (entry graph, task auto-load, journey mode, or graph mode). 'build': structured build spec for an entry. 'neighborhood': typed graph neighborhood for an entry \u2014 blocking chain, dependencies, parent context, tensions, staleness. 'changes': entries modified and relations created since a timestamp. Requires 'since' parameter. 'chain': directed traversal along one relation type to depth 4. Requires entryId. Optional: direction, relationType, maxHops (1-4). 'cross-cut': structural aggregation \u2014 all relations of a given type grouped by source collection. Requires 'relationType' parameter. 'incremental': delta since last brief run for a skill. Requires 'skill' parameter. Returns only entries changed since the skill's last brief. 'brief': compound intelligence query. Requires 'briefType' parameter: 'steering' (changes + structure + delta + readiness), 'confidence' (changes + active bets + tensions), or 'delta' (changes + relations since timestamp). Optional 'since' for delta type. 'last-verified-brief': fetch the most recent verified brief snapshot for a (templateId, scopeKey) pair (absorbs documents action=get-last-verified-brief). Requires templateId and scopeKey."
   ),
-  entryId: z10.string().max(200).optional().describe("For 'build'/'neighborhood'/'chain': entry ID, e.g. '<PREFIX>-<n>'. For 'gather': optional entry ID for entry-graph mode."),
-  mapEntryId: z10.string().max(200).optional().describe(
+  entryId: z12.string().max(200).optional().describe("For 'build'/'neighborhood'/'chain': entry ID, e.g. '<PREFIX>-<n>'. For 'gather': optional entry ID for entry-graph mode."),
+  mapEntryId: z12.string().max(200).optional().describe(
     "For 'gather': journey map entry ID for journey-aware context. Returns context organised by journey stage. Takes precedence over entryId when both are supplied. Example: '<PREFIX>-<n>'."
   ),
-  task: z10.string().max(2e3).optional().describe("For 'gather': natural-language task description for loading task-relevant governance, binding constraints, and supporting context."),
-  since: z10.string().max(200).optional().describe(
+  task: z12.string().max(2e3).optional().describe("For 'gather': natural-language task description for loading task-relevant governance, binding constraints, and supporting context."),
+  since: z12.string().max(200).optional().describe(
     "For 'changes': ISO 8601 timestamp \u2014 returns entries/relations modified since this time. For 'brief' briefType='delta': optional custom timestamp. Example: '2026-03-24T00:00:00Z'."
   ),
-  direction: z10.enum(["outgoing", "incoming"]).default("outgoing").optional().describe("For 'chain' action: traversal direction. 'outgoing' follows relations from source, 'incoming' follows relations to source. Default: outgoing."),
-  relationType: z10.string().max(200).optional().describe(
+  direction: z12.enum(["outgoing", "incoming"]).default("outgoing").optional().describe("For 'chain' action: traversal direction. 'outgoing' follows relations from source, 'incoming' follows relations to source. Default: outgoing."),
+  relationType: z12.string().max(200).optional().describe(
     "Relation type filter. For 'chain': optional filter to traverse only this relation type. For 'cross-cut': required \u2014 scans all relations of this type across the workspace. Examples: 'part_of', 'informs', 'governs', 'blocks', 'depends_on'."
   ),
-  mode: z10.enum(["search", "graph"]).default("search").optional().describe("For gather: 'search' (default) or 'graph' (enhanced with provenance paths). Ignored when mapEntryId is provided."),
-  maxHops: z10.number().min(1).max(4).default(2).describe("Relation traversal depth (1=direct only, 2=default, 3=wide net, 4=deep chain walk)"),
-  maxResults: z10.number().min(1).max(25).default(10).optional().describe("Max entries to return in gather task mode (default 10)"),
-  strategy: z10.enum(["hybrid", "keyword"]).default("keyword").optional().describe("Seed strategy for task-based gather: 'keyword' (FTS only, default) or 'hybrid' (vector + FTS). Only affects task mode."),
-  skill: z10.string().max(200).optional().describe(
+  mode: z12.enum(["search", "graph"]).default("search").optional().describe("For gather: 'search' (default) or 'graph' (enhanced with provenance paths). Ignored when mapEntryId is provided."),
+  maxHops: z12.number().min(1).max(4).default(2).describe("Relation traversal depth (1=direct only, 2=default, 3=wide net, 4=deep chain walk)"),
+  maxResults: z12.number().min(1).max(25).default(10).optional().describe("Max entries to return in gather task mode (default 10)"),
+  strategy: z12.enum(["hybrid", "keyword"]).default("keyword").optional().describe("Seed strategy for task-based gather: 'keyword' (FTS only, default) or 'hybrid' (vector + FTS). Only affects task mode."),
+  skill: z12.string().max(200).optional().describe(
     "Skill name for 'incremental' action \u2014 identifies which skill's brief history to compare against. Examples: 'preflight', 'shaping', 'review'. Required when action is 'incremental'."
   ),
-  briefType: z10.enum(["steering", "confidence", "delta"]).optional().describe(
+  briefType: z12.enum(["steering", "confidence", "delta"]).optional().describe(
     "Compound query type for 'brief' action. 'steering': 7d changes + structural aggregation (part_of, depends_on, constrains) + incremental delta + workspace readiness. 'confidence': 7d changes + active bets summary + active tensions breakdown. 'delta': changes + relations since a custom timestamp (use 'since' param). Required when action is 'brief'."
   ),
-  templateId: z10.string().max(200).optional().describe(
+  templateId: z12.string().max(200).optional().describe(
     "For 'last-verified-brief': brief template identifier \u2014 currently 'steering-brief' is the only registered template."
   ),
-  scopeKey: z10.string().max(200).optional().describe(
+  scopeKey: z12.string().max(200).optional().describe(
     "For 'last-verified-brief': canonical scope key \u2014 'workspace:<workspaceId>' or 'initiative:<INI-ID>'."
   )
 });
-var contextGatherVariant = z10.object({
-  action: z10.literal("gather"),
-  entryId: z10.string().max(200).optional(),
-  mapEntryId: z10.string().max(200).optional(),
-  task: z10.string().max(2e3).optional(),
-  mode: z10.enum(["search", "graph"]).optional().default("search"),
-  maxHops: z10.number().min(1).max(4).optional().default(2),
-  maxResults: z10.number().min(1).max(25).optional().default(10),
-  strategy: z10.enum(["hybrid", "keyword"]).optional().default("keyword")
+var contextGatherVariant = z12.object({
+  action: z12.literal("gather"),
+  entryId: z12.string().max(200).optional(),
+  mapEntryId: z12.string().max(200).optional(),
+  task: z12.string().max(2e3).optional(),
+  mode: z12.enum(["search", "graph"]).optional().default("search"),
+  maxHops: z12.number().min(1).max(4).optional().default(2),
+  maxResults: z12.number().min(1).max(25).optional().default(10),
+  strategy: z12.enum(["hybrid", "keyword"]).optional().default("keyword")
 });
-var contextBuildVariant = z10.object({
-  action: z10.literal("build"),
-  entryId: z10.string().max(200),
-  maxHops: z10.number().min(1).max(4).optional().default(2)
+var contextBuildVariant = z12.object({
+  action: z12.literal("build"),
+  entryId: z12.string().max(200),
+  maxHops: z12.number().min(1).max(4).optional().default(2)
 });
-var contextNeighborhoodVariant = z10.object({
-  action: z10.literal("neighborhood"),
-  entryId: z10.string().max(200)
+var contextNeighborhoodVariant = z12.object({
+  action: z12.literal("neighborhood"),
+  entryId: z12.string().max(200)
 });
-var contextChangesVariant = z10.object({
-  action: z10.literal("changes"),
-  since: z10.string().max(200)
+var contextChangesVariant = z12.object({
+  action: z12.literal("changes"),
+  since: z12.string().max(200)
 });
-var contextChainVariant = z10.object({
-  action: z10.literal("chain"),
-  entryId: z10.string().max(200),
-  direction: z10.enum(["outgoing", "incoming"]).optional().default("outgoing"),
-  maxHops: z10.number().min(1).max(4).optional().default(2),
-  relationType: z10.string().max(200).optional()
+var contextChainVariant = z12.object({
+  action: z12.literal("chain"),
+  entryId: z12.string().max(200),
+  direction: z12.enum(["outgoing", "incoming"]).optional().default("outgoing"),
+  maxHops: z12.number().min(1).max(4).optional().default(2),
+  relationType: z12.string().max(200).optional()
 });
-var contextCrossCutVariant = z10.object({
-  action: z10.literal("cross-cut"),
-  relationType: z10.string().max(200)
+var contextCrossCutVariant = z12.object({
+  action: z12.literal("cross-cut"),
+  relationType: z12.string().max(200)
 });
-var contextIncrementalVariant = z10.object({
-  action: z10.literal("incremental"),
-  skill: z10.string().max(200)
+var contextIncrementalVariant = z12.object({
+  action: z12.literal("incremental"),
+  skill: z12.string().max(200)
 });
-var contextBriefVariant = z10.object({
-  action: z10.literal("brief"),
-  briefType: z10.enum(["steering", "confidence", "delta"]),
-  since: z10.string().max(200).optional()
+var contextBriefVariant = z12.object({
+  action: z12.literal("brief"),
+  briefType: z12.enum(["steering", "confidence", "delta"]),
+  since: z12.string().max(200).optional()
 });
-var contextLastVerifiedBriefVariant = z10.object({
-  action: z10.literal("last-verified-brief"),
-  templateId: z10.string().max(200),
-  scopeKey: z10.string().max(200)
+var contextLastVerifiedBriefVariant = z12.object({
+  action: z12.literal("last-verified-brief"),
+  templateId: z12.string().max(200),
+  scopeKey: z12.string().max(200)
 });
-var contextActionUnion = z10.discriminatedUnion("action", [
+var contextActionUnion = z12.discriminatedUnion("action", [
   contextGatherVariant,
   contextBuildVariant,
   contextNeighborhoodVariant,
@@ -6560,20 +7015,20 @@ function formatTimeAgo(ms) {
 }
 
 // src/tools/collections.ts
-import { z as z12 } from "zod/v3";
+import { z as z14 } from "zod/v3";
 
 // src/tools/labels.ts
-import { z as z11 } from "zod/v3";
-var labelsSchema = z11.object({
-  action: z11.enum(["list", "create", "update", "delete", "apply", "remove"]).describe("Action: list all labels, create/update/delete a label, or apply/remove a label on an entry"),
-  slug: z11.string().max(200).optional().describe("Label slug (required for create/update/delete/apply/remove)"),
-  name: z11.string().max(500).optional().describe("Display name (required for create)"),
-  color: z11.string().max(50).optional().describe("Hex color, e.g. '#ef4444'"),
-  description: z11.string().max(2e3).optional().describe("What this label means"),
-  parentSlug: z11.string().max(200).optional().describe("Parent group slug for label hierarchy"),
-  isGroup: z11.boolean().optional().describe("True if this is a group container, not a taggable label"),
-  order: z11.number().optional().describe("Sort order within its group"),
-  entryId: z11.string().max(200).optional().describe("Entry ID for apply/remove actions")
+import { z as z13 } from "zod/v3";
+var labelsSchema = z13.object({
+  action: z13.enum(["list", "create", "update", "delete", "apply", "remove"]).describe("Action: list all labels, create/update/delete a label, or apply/remove a label on an entry"),
+  slug: z13.string().max(200).optional().describe("Label slug (required for create/update/delete/apply/remove)"),
+  name: z13.string().max(500).optional().describe("Display name (required for create)"),
+  color: z13.string().max(50).optional().describe("Hex color, e.g. '#ef4444'"),
+  description: z13.string().max(2e3).optional().describe("What this label means"),
+  parentSlug: z13.string().max(200).optional().describe("Parent group slug for label hierarchy"),
+  isGroup: z13.boolean().optional().describe("True if this is a group container, not a taggable label"),
+  order: z13.number().optional().describe("Sort order within its group"),
+  entryId: z13.string().max(200).optional().describe("Entry ID for apply/remove actions")
 });
 async function handleLabelsList() {
   const labels = await kernelQuery("chain.listLabels");
@@ -6678,128 +7133,128 @@ var COLLECTIONS_ACTIONS = [
   "label-apply",
   "label-remove"
 ];
-var qualityCriterionSchema = z12.object({
-  field: z12.string().max(200).describe("Entry data field key this criterion applies to, e.g. 'description', 'owner'"),
+var qualityCriterionSchema = z14.object({
+  field: z14.string().max(200).describe("Entry data field key this criterion applies to, e.g. 'description', 'owner'"),
   // WP-480 S1: `max_length` — must mirror the Convex rule union, or the tool rejects a
   // valid criterion before the request ever reaches the server.
-  rule: z12.enum(["required", "min_length", "max_length", "pattern"]).describe("'required': field must be non-empty (blocks accept). 'min_length': minimum string length (warns). 'max_length': maximum string length (warns). 'pattern': regex match (warns)."),
-  value: z12.string().max(500).optional().describe("For min_length/max_length: the length bound as a string integer. For pattern: the regex string. Unused for 'required'.")
+  rule: z14.enum(["required", "min_length", "max_length", "pattern"]).describe("'required': field must be non-empty (blocks accept). 'min_length': minimum string length (warns). 'max_length': maximum string length (warns). 'pattern': regex match (warns)."),
+  value: z14.string().max(500).optional().describe("For min_length/max_length: the length bound as a string integer. For pattern: the regex string. Unused for 'required'.")
 });
-var fieldSchema = z12.object({
-  key: z12.string().max(200).describe("Field key, e.g. 'description', 'severity', 'status'"),
-  label: z12.string().max(200).describe("Display label, e.g. 'Description', 'Severity'"),
-  type: z12.string().max(50).describe("Field type: 'string', 'select', 'array', 'number', 'boolean'"),
-  required: z12.boolean().optional().describe("Whether this field is required"),
-  options: z12.array(z12.string().max(200)).max(200).optional().describe("Options for 'select' type fields"),
-  searchable: z12.boolean().optional().describe("Whether this field is included in full-text search"),
-  displayHint: z12.enum(["hero", "badge", "meta", "section", "hidden", "inline-meta"]).optional().describe("V2 rendering hint: how the field should be displayed in Cortex"),
-  zone: z12.enum(["header", "body", "meta"]).optional().describe("V2 layout zone: where the field appears in the entry view"),
-  colorMap: z12.record(z12.string().max(50)).optional().describe("V2 value-to-semantic-color mapping, e.g. { critical: 'danger', low: 'success' }"),
+var fieldSchema = z14.object({
+  key: z14.string().max(200).describe("Field key, e.g. 'description', 'severity', 'status'"),
+  label: z14.string().max(200).describe("Display label, e.g. 'Description', 'Severity'"),
+  type: z14.string().max(50).describe("Field type: 'string', 'select', 'array', 'number', 'boolean'"),
+  required: z14.boolean().optional().describe("Whether this field is required"),
+  options: z14.array(z14.string().max(200)).max(200).optional().describe("Options for 'select' type fields"),
+  searchable: z14.boolean().optional().describe("Whether this field is included in full-text search"),
+  displayHint: z14.enum(["hero", "badge", "meta", "section", "hidden", "inline-meta"]).optional().describe("V2 rendering hint: how the field should be displayed in Cortex"),
+  zone: z14.enum(["header", "body", "meta"]).optional().describe("V2 layout zone: where the field appears in the entry view"),
+  colorMap: z14.record(z14.string().max(50)).optional().describe("V2 value-to-semantic-color mapping, e.g. { critical: 'danger', low: 'success' }"),
   // ENT-61
-  accentSource: z12.boolean().optional().describe("When true, this field's colorMap value drives the card-level accent styling"),
+  accentSource: z14.boolean().optional().describe("When true, this field's colorMap value drives the card-level accent styling"),
   // ENT-61
-  iconMap: z12.record(z12.string(), z12.string().max(50)).optional().describe("Maps field values to icons (emoji/symbol), prepended to badge text"),
-  helpText: z12.string().max(2e3).optional().describe("Help text shown in editors and describe output"),
-  optionDescriptions: z12.record(z12.string().max(500)).optional().describe("Per-option guidance for select fields"),
+  iconMap: z14.record(z14.string(), z14.string().max(50)).optional().describe("Maps field values to icons (emoji/symbol), prepended to badge text"),
+  helpText: z14.string().max(2e3).optional().describe("Help text shown in editors and describe output"),
+  optionDescriptions: z14.record(z14.string().max(500)).optional().describe("Per-option guidance for select fields"),
   // BET-136
-  semanticRole: z12.enum(["problem", "appetite", "elements", "architecture", "done_when", "risks", "exclusions"]).optional().describe("Semantic role for schema-driven consumers \u2014 enables field-key-independent validation and rendering"),
+  semanticRole: z14.enum(["problem", "appetite", "elements", "architecture", "done_when", "risks", "exclusions"]).optional().describe("Semantic role for schema-driven consumers \u2014 enables field-key-independent validation and rendering"),
   // BET-196
-  maxLength: z12.number().optional().describe("Maximum character length for field values. Three-tier resolution: explicit > displayHint > type fallback."),
+  maxLength: z14.number().optional().describe("Maximum character length for field values. Three-tier resolution: explicit > displayHint > type fallback."),
   // BET-196
-  minLength: z12.number().optional().describe("Minimum character length for field values. Only explicit \u2014 no defaults.")
+  minLength: z14.number().optional().describe("Minimum character length for field values. Only explicit \u2014 no defaults.")
 });
-var collectionsSchema = z12.object({
-  action: z12.enum(COLLECTIONS_ACTIONS).describe(
+var collectionsSchema = z14.object({
+  action: z14.enum(COLLECTIONS_ACTIONS).describe(
     "'list': browse all collections. 'create': create a new collection. 'update': update an existing collection. 'describe': full documentation for one collection \u2014 fields, option guides, usage guidance, examples. 'audit': health report for all collections \u2014 missing classification, icon, displayHint coverage, and field schema gaps. 'export': full system_collection_definitions export with classification metadata (thinkingLayer, classificationPriority, classificationCheck, classificationSignals, governanceRole, governanceFunction, timelineRole, canBeElementOf, descriptionFieldKey). Admin only. 'label-list'/'label-create'/'label-update'/'label-delete'/'label-apply'/'label-remove': manage workspace labels (absorbs the `labels` tool)."
   ),
-  slug: z12.string().max(200).optional().describe("URL-safe identifier for create/update, e.g. 'glossary', 'tech-debt'. For label-*: label slug."),
-  name: z12.string().max(500).optional().describe("Display name for create, or new name for update. For label-create: label display name."),
-  description: z12.string().max(2e4).optional().describe("What this collection is for. For label-create/label-update: what the label means."),
-  purpose: z12.string().max(2e3).optional().describe("Why this collection exists \u2014 strategic reason"),
-  icon: z12.string().max(50).optional().describe("Emoji icon for the collection"),
-  navGroup: z12.enum(["daily", "strategic", "governance", "reference", "collections"]).optional().describe("Sidebar placement: 'daily', 'strategic', 'governance', 'reference', 'collections'"),
-  fields: z12.array(fieldSchema).max(200).optional().describe("Field definitions for create, or replacement schema for update (replaces all fields)"),
+  slug: z14.string().max(200).optional().describe("URL-safe identifier for create/update, e.g. 'glossary', 'tech-debt'. For label-*: label slug."),
+  name: z14.string().max(500).optional().describe("Display name for create, or new name for update. For label-create: label display name."),
+  description: z14.string().max(2e4).optional().describe("What this collection is for. For label-create/label-update: what the label means."),
+  purpose: z14.string().max(2e3).optional().describe("Why this collection exists \u2014 strategic reason"),
+  icon: z14.string().max(50).optional().describe("Emoji icon for the collection"),
+  navGroup: z14.enum(["daily", "strategic", "governance", "reference", "collections"]).optional().describe("Sidebar placement: 'daily', 'strategic', 'governance', 'reference', 'collections'"),
+  fields: z14.array(fieldSchema).max(200).optional().describe("Field definitions for create, or replacement schema for update (replaces all fields)"),
   // ENT-62
-  defaultCanonicalKey: z12.string().max(200).optional().describe("The canonical_key entries in this collection default to (e.g. 'decision', 'insight'). Consumers read from collection doc; code map is fallback."),
+  defaultCanonicalKey: z14.string().max(200).optional().describe("The canonical_key entries in this collection default to (e.g. 'decision', 'insight'). Consumers read from collection doc; code map is fallback."),
   // ENT-67
-  defaultWorkflowStatus: z12.string().max(200).optional().describe("Default workflowStatus for new entries. Must be in validWorkflowStatuses when set (e.g. 'hypothesis' for insights)."),
+  defaultWorkflowStatus: z14.string().max(200).optional().describe("Default workflowStatus for new entries. Must be in validWorkflowStatuses when set (e.g. 'hypothesis' for insights)."),
   // ENT-65
-  validWorkflowStatuses: z12.array(z12.string().max(200)).max(50).optional().describe("The allowed workflowStatus values for entries in this collection. New entries are validated against this list. Empty array means no constraint."),
+  validWorkflowStatuses: z14.array(z14.string().max(200)).max(50).optional().describe("The allowed workflowStatus values for entries in this collection. New entries are validated against this list. Empty array means no constraint."),
   // ENT-65, FEAT-200
-  classificationCheck: z12.string().max(500).optional().describe("LLM decision-tree check for this collection (3\u2013500 chars). Guides the classifier in routing entries here."),
+  classificationCheck: z14.string().max(500).optional().describe("LLM decision-tree check for this collection (3\u2013500 chars). Guides the classifier in routing entries here."),
   // ENT-65, FEAT-200
-  classificationPriority: z12.number().optional().describe("Classifier priority (1\u20139, lower = higher priority). Used with classificationCheck to order the decision tree."),
+  classificationPriority: z14.number().optional().describe("Classifier priority (1\u20139, lower = higher priority). Used with classificationCheck to order the decision tree."),
   // FEAT-301 Slice 2: quality gate criteria and usage guidance.
   // FEAT-257
-  qualityCriteria: z12.array(qualityCriterionSchema).max(50).optional().describe("Per-collection accept gate rules. 'required' rule hard-blocks accepts on empty fields; 'min_length'/'pattern' rules warn. Pass an empty array to clear all criteria."),
-  usageGuidance: z12.string().max(2e4).optional().describe("Plain-text guidance shown to agents and users: when to use this collection, when not to, and what makes a good entry."),
+  qualityCriteria: z14.array(qualityCriterionSchema).max(50).optional().describe("Per-collection accept gate rules. 'required' rule hard-blocks accepts on empty fields; 'min_length'/'pattern' rules warn. Pass an empty array to clear all criteria."),
+  usageGuidance: z14.string().max(2e4).optional().describe("Plain-text guidance shown to agents and users: when to use this collection, when not to, and what makes a good entry."),
   // For label-*
-  color: z12.string().max(50).optional().describe("For label-create/label-update: hex color, e.g. '#ef4444'."),
-  parentSlug: z12.string().max(200).optional().describe("For label-create: parent group slug for label hierarchy."),
-  isGroup: z12.boolean().optional().describe("For label-create/label-update: true if this is a group container, not a taggable label."),
-  order: z12.number().optional().describe("For label-create/label-update: sort order within its group."),
-  entryId: z12.string().max(200).optional().describe("For label-apply/label-remove: entry ID.")
+  color: z14.string().max(50).optional().describe("For label-create/label-update: hex color, e.g. '#ef4444'."),
+  parentSlug: z14.string().max(200).optional().describe("For label-create: parent group slug for label hierarchy."),
+  isGroup: z14.boolean().optional().describe("For label-create/label-update: true if this is a group container, not a taggable label."),
+  order: z14.number().optional().describe("For label-create/label-update: sort order within its group."),
+  entryId: z14.string().max(200).optional().describe("For label-apply/label-remove: entry ID.")
 });
-var collectionsListVariant = z12.object({ action: z12.literal("list") });
-var collectionsDescribeVariant = z12.object({ action: z12.literal("describe"), slug: z12.string().max(200) });
-var collectionsCreateVariant = z12.object({
-  action: z12.literal("create"),
-  slug: z12.string().max(200),
-  name: z12.string().max(500),
-  description: z12.string().max(2e4).optional(),
-  purpose: z12.string().max(2e3).optional(),
-  icon: z12.string().max(50).optional(),
-  navGroup: z12.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
-  fields: z12.array(fieldSchema).min(1),
-  defaultCanonicalKey: z12.string().max(200).optional(),
-  defaultWorkflowStatus: z12.string().max(200).optional(),
-  validWorkflowStatuses: z12.array(z12.string().max(200)).optional(),
-  classificationCheck: z12.string().max(500).optional(),
-  classificationPriority: z12.number().optional()
+var collectionsListVariant = z14.object({ action: z14.literal("list") });
+var collectionsDescribeVariant = z14.object({ action: z14.literal("describe"), slug: z14.string().max(200) });
+var collectionsCreateVariant = z14.object({
+  action: z14.literal("create"),
+  slug: z14.string().max(200),
+  name: z14.string().max(500),
+  description: z14.string().max(2e4).optional(),
+  purpose: z14.string().max(2e3).optional(),
+  icon: z14.string().max(50).optional(),
+  navGroup: z14.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
+  fields: z14.array(fieldSchema).min(1),
+  defaultCanonicalKey: z14.string().max(200).optional(),
+  defaultWorkflowStatus: z14.string().max(200).optional(),
+  validWorkflowStatuses: z14.array(z14.string().max(200)).optional(),
+  classificationCheck: z14.string().max(500).optional(),
+  classificationPriority: z14.number().optional()
 });
-var collectionsUpdateVariant = z12.object({
-  action: z12.literal("update"),
-  slug: z12.string().max(200),
-  name: z12.string().max(500).optional(),
-  description: z12.string().max(2e4).optional(),
-  purpose: z12.string().max(2e3).optional(),
-  icon: z12.string().max(50).optional(),
-  navGroup: z12.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
-  fields: z12.array(fieldSchema).optional(),
-  defaultCanonicalKey: z12.string().max(200).optional(),
-  defaultWorkflowStatus: z12.string().max(200).optional(),
-  validWorkflowStatuses: z12.array(z12.string().max(200)).optional(),
-  classificationCheck: z12.string().max(500).optional(),
-  classificationPriority: z12.number().optional(),
-  qualityCriteria: z12.array(qualityCriterionSchema).optional(),
-  usageGuidance: z12.string().max(2e4).optional()
+var collectionsUpdateVariant = z14.object({
+  action: z14.literal("update"),
+  slug: z14.string().max(200),
+  name: z14.string().max(500).optional(),
+  description: z14.string().max(2e4).optional(),
+  purpose: z14.string().max(2e3).optional(),
+  icon: z14.string().max(50).optional(),
+  navGroup: z14.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
+  fields: z14.array(fieldSchema).optional(),
+  defaultCanonicalKey: z14.string().max(200).optional(),
+  defaultWorkflowStatus: z14.string().max(200).optional(),
+  validWorkflowStatuses: z14.array(z14.string().max(200)).optional(),
+  classificationCheck: z14.string().max(500).optional(),
+  classificationPriority: z14.number().optional(),
+  qualityCriteria: z14.array(qualityCriterionSchema).optional(),
+  usageGuidance: z14.string().max(2e4).optional()
 });
-var collectionsAuditVariant = z12.object({ action: z12.literal("audit") });
-var collectionsExportVariant = z12.object({ action: z12.literal("export") });
-var collectionsLabelListVariant = z12.object({ action: z12.literal("label-list") });
-var collectionsLabelCreateVariant = z12.object({
-  action: z12.literal("label-create"),
-  slug: z12.string().max(200),
-  name: z12.string().max(500),
-  color: z12.string().max(50).optional(),
-  description: z12.string().max(2e3).optional(),
-  parentSlug: z12.string().max(200).optional(),
-  isGroup: z12.boolean().optional(),
-  order: z12.number().optional()
+var collectionsAuditVariant = z14.object({ action: z14.literal("audit") });
+var collectionsExportVariant = z14.object({ action: z14.literal("export") });
+var collectionsLabelListVariant = z14.object({ action: z14.literal("label-list") });
+var collectionsLabelCreateVariant = z14.object({
+  action: z14.literal("label-create"),
+  slug: z14.string().max(200),
+  name: z14.string().max(500),
+  color: z14.string().max(50).optional(),
+  description: z14.string().max(2e3).optional(),
+  parentSlug: z14.string().max(200).optional(),
+  isGroup: z14.boolean().optional(),
+  order: z14.number().optional()
 });
-var collectionsLabelUpdateVariant = z12.object({
-  action: z12.literal("label-update"),
-  slug: z12.string().max(200),
-  name: z12.string().max(500).optional(),
-  color: z12.string().max(50).optional(),
-  description: z12.string().max(2e3).optional(),
-  isGroup: z12.boolean().optional(),
-  order: z12.number().optional()
+var collectionsLabelUpdateVariant = z14.object({
+  action: z14.literal("label-update"),
+  slug: z14.string().max(200),
+  name: z14.string().max(500).optional(),
+  color: z14.string().max(50).optional(),
+  description: z14.string().max(2e3).optional(),
+  isGroup: z14.boolean().optional(),
+  order: z14.number().optional()
 });
-var collectionsLabelDeleteVariant = z12.object({ action: z12.literal("label-delete"), slug: z12.string().max(200) });
-var collectionsLabelApplyVariant = z12.object({ action: z12.literal("label-apply"), slug: z12.string().max(200), entryId: z12.string().max(200) });
-var collectionsLabelRemoveVariant = z12.object({ action: z12.literal("label-remove"), slug: z12.string().max(200), entryId: z12.string().max(200) });
-var collectionsActionUnion = z12.discriminatedUnion("action", [
+var collectionsLabelDeleteVariant = z14.object({ action: z14.literal("label-delete"), slug: z14.string().max(200) });
+var collectionsLabelApplyVariant = z14.object({ action: z14.literal("label-apply"), slug: z14.string().max(200), entryId: z14.string().max(200) });
+var collectionsLabelRemoveVariant = z14.object({ action: z14.literal("label-remove"), slug: z14.string().max(200), entryId: z14.string().max(200) });
+var collectionsActionUnion = z14.discriminatedUnion("action", [
   collectionsListVariant,
   collectionsDescribeVariant,
   collectionsCreateVariant,
@@ -7184,7 +7639,7 @@ async function handleExport() {
 }
 
 // src/tools/orient.ts
-import { z as z16 } from "zod/v3";
+import { z as z18 } from "zod/v3";
 
 // src/tools/planned-work.ts
 function buildPlannedWork(allEntries) {
@@ -8112,12 +8567,12 @@ function replaceVocabTokens(body, workspaceCtx, collectionCtxMap) {
 }
 
 // src/tools/start_pb.ts
-import { z as z14 } from "zod/v3";
+import { z as z16 } from "zod/v3";
 
 // src/tools/skills.ts
-import { z as z13 } from "zod/v3";
-var skillsSchema = z13.object({
-  entryId: z13.string().min(1).describe(
+import { z as z15 } from "zod/v3";
+var skillsSchema = z15.object({
+  entryId: z15.string().min(1).describe(
     "Workspace-scoped skill entry id (e.g. 'SKILL-pb-setup'). The tool refuses non-skill entries (canonicalKey !== 'skill') with INVALID_KIND."
   )
 });
@@ -8130,8 +8585,8 @@ async function loadSkillBody(entryId) {
 }
 
 // src/tools/start_pb.ts
-var startPbSchema = z14.object({
-  task: z14.string().max(2e3).optional().describe(
+var startPbSchema = z16.object({
+  task: z16.string().max(2e3).optional().describe(
     "What you're about to work on (e.g. 'implementing auth middleware'). Grounded/connected workspaces: filters governance to show relevant principles, standards, and business rules. Blank/seeded workspaces: ignored (setup flow takes over)."
   )
   // TEN-2431: no `scope` param — start_pb's governance matches orient's scope-BLIND RENDERED
@@ -8490,15 +8945,15 @@ ${FEEDBACK_HINT}` }],
 }
 
 // src/tools/record_activation.ts
-import { z as z15 } from "zod/v3";
-var recordActivationSchema = z15.object({
-  confirmedEntryCount: z15.number().int().min(0).describe(
+import { z as z17 } from "zod/v3";
+var recordActivationSchema = z17.object({
+  confirmedEntryCount: z17.number().int().min(0).describe(
     "Confirmed-entry count from the Phase 4 capture loop. The mutation enforces >=10."
   ),
-  entriesAcrossCollections: z15.number().int().min(0).describe(
+  entriesAcrossCollections: z17.number().int().min(0).describe(
     "Number of distinct collections those entries span. The mutation enforces >=2 (diversity soft-gate)."
   ),
-  retrievalDemoConfirmed: z15.boolean().describe(
+  retrievalDemoConfirmed: z17.boolean().describe(
     "True if the retrieval round-trip ran successfully in Phase 4. The mutation rejects false."
   )
 });
@@ -8589,65 +9044,65 @@ async function markOrientedWithSnapshotFallback(agentSessionId, coherenceSnapsho
   }
 }
 var ORIENT_ACTIONS = ["start", "task", "record-activation"];
-var orientSchema = z16.object({
-  action: z16.enum(ORIENT_ACTIONS).optional().default("task").describe(
+var orientSchema = z18.object({
+  action: z18.enum(ORIENT_ACTIONS).optional().default("task").describe(
     "'start': universal session opener (absorbs start_pb) \u2014 stage-aware setup skill or standup briefing. 'task': task-grounded context loader \u2014 the original orient behavior. 'record-activation': chat-only activation receipt writer (absorbs record_activation)."
   ),
-  mode: z16.enum(["full", "brief"]).optional().default("full").describe("For 'task': full = full context (default). brief = compact summary for mid-session re-orientation. Prefer using the `tier` param for depth control."),
-  tier: z16.enum(["summary", "standard", "full"]).optional().describe(
+  mode: z18.enum(["full", "brief"]).optional().default("full").describe("For 'task': full = full context (default). brief = compact summary for mid-session re-orientation. Prefer using the `tier` param for depth control."),
+  tier: z18.enum(["summary", "standard", "full"]).optional().describe(
     "For 'task': payload depth. Defaults to summary (~10 KB) when task is provided; standard (~256 KB) when task is absent. Pass summary, standard, or full to override."
   ),
-  task: z16.string().max(2e3).optional().describe(
+  task: z18.string().max(2e3).optional().describe(
     "For 'task': natural-language task description for task-scoped context. For 'start': what you're about to work on. When provided to 'task', orient returns scored, relevant entries for the task."
   ),
-  scope: z16.string().max(200).optional().describe("For 'task': optional domain scope to filter governance to entries relevant for this domain. Forwarded to Convex for workspace-specific validation."),
+  scope: z18.string().max(200).optional().describe("For 'task': optional domain scope to filter governance to entries relevant for this domain. Forwarded to Convex for workspace-specific validation."),
   // WP-486 Slice 1 (FEAT-1371, TEN-2724): the startup-signal envelope `resolveStartupDomain` already
   // consumes (`startupResolver.ts:344-379`) but this tool never sent. Nested to match the server's
   // `StartupResolutionSignals` shape exactly — every field optional, sanitized server-side.
-  startupSignals: z16.object({
-    changedPaths: z16.array(z16.string()).max(25).optional().describe("Paths changed in the current working tree, if known (e.g. from a prior git status/diff tool call)."),
-    reviewedArtifactRefs: z16.array(z16.string()).max(25).optional().describe("Chain entry IDs the caller has already reviewed this session, if tracked."),
-    branchName: z16.string().max(120).optional().describe("Current git branch name, if known."),
-    worktreeName: z16.string().max(120).optional().describe("Current worktree/directory name, if known.")
+  startupSignals: z18.object({
+    changedPaths: z18.array(z18.string()).max(25).optional().describe("Paths changed in the current working tree, if known (e.g. from a prior git status/diff tool call)."),
+    reviewedArtifactRefs: z18.array(z18.string()).max(25).optional().describe("Chain entry IDs the caller has already reviewed this session, if tracked."),
+    branchName: z18.string().max(120).optional().describe("Current git branch name, if known."),
+    worktreeName: z18.string().max(120).optional().describe("Current worktree/directory name, if known.")
   }).optional().describe("For 'task': best-effort startup signals for domain resolution \u2014 changedPaths/reviewedArtifactRefs/branchName/worktreeName. All optional; omit fields you don't know."),
-  invocationPath: z16.enum(["session-start", "session-close", "manual-orient", "handshake", "unknown"]).optional().describe("For 'task': how this orient was invoked. Defaults to 'manual-orient' (the direct `orient task=...` call shape) when omitted."),
-  confirmedEntryCount: z16.number().int().min(0).optional().describe(
+  invocationPath: z18.enum(["session-start", "session-close", "manual-orient", "handshake", "unknown"]).optional().describe("For 'task': how this orient was invoked. Defaults to 'manual-orient' (the direct `orient task=...` call shape) when omitted."),
+  confirmedEntryCount: z18.number().int().min(0).optional().describe(
     "For 'record-activation': confirmed-entry count from the Phase 4 capture loop. The mutation enforces >=10."
   ),
-  entriesAcrossCollections: z16.number().int().min(0).optional().describe(
+  entriesAcrossCollections: z18.number().int().min(0).optional().describe(
     "For 'record-activation': number of distinct collections those entries span. The mutation enforces >=2 (diversity soft-gate)."
   ),
-  retrievalDemoConfirmed: z16.boolean().optional().describe(
+  retrievalDemoConfirmed: z18.boolean().optional().describe(
     "For 'record-activation': true if the retrieval round-trip ran successfully in Phase 4. The mutation rejects false."
   )
 });
-var orientStartVariant = z16.object({
-  action: z16.literal("start"),
-  task: z16.string().max(2e3).optional()
+var orientStartVariant = z18.object({
+  action: z18.literal("start"),
+  task: z18.string().max(2e3).optional()
 });
-var orientTaskVariant = z16.object({
-  action: z16.literal("task"),
-  mode: z16.enum(["full", "brief"]).optional().default("full"),
-  tier: z16.enum(["summary", "standard", "full"]).optional(),
-  task: z16.string().max(2e3).optional(),
-  scope: z16.string().max(200).optional(),
+var orientTaskVariant = z18.object({
+  action: z18.literal("task"),
+  mode: z18.enum(["full", "brief"]).optional().default("full"),
+  tier: z18.enum(["summary", "standard", "full"]).optional(),
+  task: z18.string().max(2e3).optional(),
+  scope: z18.string().max(200).optional(),
   // WP-486 Slice 1 (FEAT-1371) — mirrors orientSchema's top-level declaration above; see its
   // doc comment for the shape rationale.
-  startupSignals: z16.object({
-    changedPaths: z16.array(z16.string()).max(25).optional(),
-    reviewedArtifactRefs: z16.array(z16.string()).max(25).optional(),
-    branchName: z16.string().max(120).optional(),
-    worktreeName: z16.string().max(120).optional()
+  startupSignals: z18.object({
+    changedPaths: z18.array(z18.string()).max(25).optional(),
+    reviewedArtifactRefs: z18.array(z18.string()).max(25).optional(),
+    branchName: z18.string().max(120).optional(),
+    worktreeName: z18.string().max(120).optional()
   }).optional(),
-  invocationPath: z16.enum(["session-start", "session-close", "manual-orient", "handshake", "unknown"]).optional()
+  invocationPath: z18.enum(["session-start", "session-close", "manual-orient", "handshake", "unknown"]).optional()
 });
-var orientRecordActivationVariant = z16.object({
-  action: z16.literal("record-activation"),
-  confirmedEntryCount: z16.number().int().min(0),
-  entriesAcrossCollections: z16.number().int().min(0),
-  retrievalDemoConfirmed: z16.boolean()
+var orientRecordActivationVariant = z18.object({
+  action: z18.literal("record-activation"),
+  confirmedEntryCount: z18.number().int().min(0),
+  entriesAcrossCollections: z18.number().int().min(0),
+  retrievalDemoConfirmed: z18.boolean()
 });
-var orientActionUnion = z16.discriminatedUnion("action", [
+var orientActionUnion = z18.discriminatedUnion("action", [
   orientStartVariant,
   orientTaskVariant,
   orientRecordActivationVariant
@@ -9488,7 +9943,7 @@ async function _handleOrient({ mode = "full", tier, task, scope, startupSignals,
 }
 
 // src/tools/workflows.ts
-import { z as z17 } from "zod/v3";
+import { z as z19 } from "zod/v3";
 
 // src/workflows/descriptor.ts
 function cloneWorkflowQuestion(question) {
@@ -10328,75 +10783,75 @@ function workflowRunOutputToText(output) {
 
 // src/tools/workflows.ts
 var WORKFLOWS_ACTIONS = ["list", "start", "checkpoint", "get-run", "load-skill"];
-var jsonValueSchema = z17.lazy(
-  () => z17.union([
-    z17.string(),
-    z17.number(),
-    z17.boolean(),
-    z17.null(),
-    z17.array(jsonValueSchema),
-    z17.record(jsonValueSchema)
+var jsonValueSchema = z19.lazy(
+  () => z19.union([
+    z19.string(),
+    z19.number(),
+    z19.boolean(),
+    z19.null(),
+    z19.array(jsonValueSchema),
+    z19.record(jsonValueSchema)
   ])
 );
-var workflowRunOutputInputSchema = z17.union([
-  z17.object({
-    format: z17.literal("freetext"),
-    value: z17.string()
+var workflowRunOutputInputSchema = z19.union([
+  z19.object({
+    format: z19.literal("freetext"),
+    value: z19.string()
   }),
-  z17.object({
-    format: z17.literal("list"),
-    value: z17.array(z17.string())
+  z19.object({
+    format: z19.literal("list"),
+    value: z19.array(z19.string())
   }),
-  z17.object({
-    format: z17.literal("choice"),
-    value: z17.union([z17.string(), z17.array(z17.string())])
+  z19.object({
+    format: z19.literal("choice"),
+    value: z19.union([z19.string(), z19.array(z19.string())])
   }),
-  z17.object({
-    format: z17.literal("structured"),
+  z19.object({
+    format: z19.literal("structured"),
     value: jsonValueSchema
   })
 ]);
-var workflowsSchema = z17.object({
-  action: z17.enum(WORKFLOWS_ACTIONS).describe(
+var workflowsSchema = z19.object({
+  action: z19.enum(WORKFLOWS_ACTIONS).describe(
     "'list': browse available workflows. 'start': start or resume a workflow \u2014 returns first (or current) round and next-step checkpoint call. 'checkpoint': record round output or final summary. 'get-run': inspect a persisted workflow run. 'load-skill': load the markdown body of a SKILL-* entry from the workspace (absorbs the `skills` tool). Requires entryId."
   ),
-  workflowId: z17.string().max(200).optional().describe("Workflow ID for start, checkpoint, or get-run, e.g. 'retro', 'implementation-review'"),
-  runId: z17.string().max(200).optional().describe("Workflow run ID: for get-run, which run to load; for checkpoint, target this run (avoids session drift \u2014 pass runId from get-run)."),
-  roundId: z17.string().max(200).optional().describe("Round ID for checkpoint, e.g. 'what-went-well'"),
-  output: z17.union([z17.string(), workflowRunOutputInputSchema]).optional().describe("The round's output \u2014 either legacy synthesized text or a typed workflow run payload."),
-  isFinal: z17.boolean().optional().describe("If true, finalize an existing durable workflow run from its terminal round and create the summary chain entry."),
-  restart: z17.boolean().optional().describe("If true, start a new durable run from the workflow's first round in the current session."),
-  summaryName: z17.string().max(500).optional().describe("Optional name for final chain entry. If omitted, the workflow summary template is used."),
-  summaryDescription: z17.string().max(2e4).optional().describe("Optional override for the final chain entry description. Defaults to the final round output text."),
-  summaryEntryId: z17.string().max(200).optional().describe("Link an existing entry as the run's summary instead of creating one. Used by facilitated workflows (e.g. shape) where the primary record is created by the specialized tool."),
-  entryId: z17.string().max(200).optional().describe("For 'load-skill': workspace-scoped skill entry id (e.g. 'SKILL-pb-setup'). Refuses non-skill entries (canonicalKey !== 'skill') with INVALID_KIND."),
+  workflowId: z19.string().max(200).optional().describe("Workflow ID for start, checkpoint, or get-run, e.g. 'retro', 'implementation-review'"),
+  runId: z19.string().max(200).optional().describe("Workflow run ID: for get-run, which run to load; for checkpoint, target this run (avoids session drift \u2014 pass runId from get-run)."),
+  roundId: z19.string().max(200).optional().describe("Round ID for checkpoint, e.g. 'what-went-well'"),
+  output: z19.union([z19.string(), workflowRunOutputInputSchema]).optional().describe("The round's output \u2014 either legacy synthesized text or a typed workflow run payload."),
+  isFinal: z19.boolean().optional().describe("If true, finalize an existing durable workflow run from its terminal round and create the summary chain entry."),
+  restart: z19.boolean().optional().describe("If true, start a new durable run from the workflow's first round in the current session."),
+  summaryName: z19.string().max(500).optional().describe("Optional name for final chain entry. If omitted, the workflow summary template is used."),
+  summaryDescription: z19.string().max(2e4).optional().describe("Optional override for the final chain entry description. Defaults to the final round output text."),
+  summaryEntryId: z19.string().max(200).optional().describe("Link an existing entry as the run's summary instead of creating one. Used by facilitated workflows (e.g. shape) where the primary record is created by the specialized tool."),
+  entryId: z19.string().max(200).optional().describe("For 'load-skill': workspace-scoped skill entry id (e.g. 'SKILL-pb-setup'). Refuses non-skill entries (canonicalKey !== 'skill') with INVALID_KIND."),
   // WP-513: team+role to create the finalize summary AS OWNER of (rung 2 only).
-  ownerTeamEntryId: z17.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning team (rung-2)."),
-  ownerRoleEntryId: z17.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning role (rung-2).")
+  ownerTeamEntryId: z19.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning team (rung-2)."),
+  ownerRoleEntryId: z19.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning role (rung-2).")
 });
-var workflowsListVariant = z17.object({ action: z17.literal("list") });
-var workflowsGetRunVariant = z17.object({
-  action: z17.literal("get-run"),
-  runId: z17.string().max(200).optional(),
-  workflowId: z17.string().max(200).optional()
+var workflowsListVariant = z19.object({ action: z19.literal("list") });
+var workflowsGetRunVariant = z19.object({
+  action: z19.literal("get-run"),
+  runId: z19.string().max(200).optional(),
+  workflowId: z19.string().max(200).optional()
 });
-var workflowsStartVariant = z17.object({ action: z17.literal("start"), workflowId: z17.string().max(200) });
-var workflowsCheckpointVariant = z17.object({
-  action: z17.literal("checkpoint"),
-  workflowId: z17.string().max(200),
-  roundId: z17.string().max(200),
-  output: z17.union([z17.string(), workflowRunOutputInputSchema]),
-  isFinal: z17.boolean().optional(),
-  restart: z17.boolean().optional(),
-  summaryName: z17.string().max(500).optional(),
-  summaryDescription: z17.string().max(2e4).optional(),
-  summaryEntryId: z17.string().max(200).optional(),
-  runId: z17.string().max(200).optional(),
-  ownerTeamEntryId: z17.string().max(200).optional(),
-  ownerRoleEntryId: z17.string().max(200).optional()
+var workflowsStartVariant = z19.object({ action: z19.literal("start"), workflowId: z19.string().max(200) });
+var workflowsCheckpointVariant = z19.object({
+  action: z19.literal("checkpoint"),
+  workflowId: z19.string().max(200),
+  roundId: z19.string().max(200),
+  output: z19.union([z19.string(), workflowRunOutputInputSchema]),
+  isFinal: z19.boolean().optional(),
+  restart: z19.boolean().optional(),
+  summaryName: z19.string().max(500).optional(),
+  summaryDescription: z19.string().max(2e4).optional(),
+  summaryEntryId: z19.string().max(200).optional(),
+  runId: z19.string().max(200).optional(),
+  ownerTeamEntryId: z19.string().max(200).optional(),
+  ownerRoleEntryId: z19.string().max(200).optional()
 });
-var workflowsLoadSkillVariant = z17.object({ action: z17.literal("load-skill"), entryId: z17.string().max(200).min(1) });
-var workflowsActionUnion = z17.discriminatedUnion("action", [
+var workflowsLoadSkillVariant = z19.object({ action: z19.literal("load-skill"), entryId: z19.string().max(200).min(1) });
+var workflowsActionUnion = z19.discriminatedUnion("action", [
   workflowsListVariant,
   workflowsGetRunVariant,
   workflowsStartVariant,
@@ -11136,10 +11591,10 @@ function parseListOutput(output) {
 }
 
 // src/tools/quality.ts
-import { z as z19 } from "zod/v3";
+import { z as z21 } from "zod/v3";
 
 // src/tools/audit.ts
-import { z as z18 } from "zod/v3";
+import { z as z20 } from "zod/v3";
 var VOCAB_TTL_MS = 5 * 60 * 1e3;
 var MAX_VOCAB_KEYS = 100;
 var vocabCache = /* @__PURE__ */ new Map();
@@ -11169,12 +11624,12 @@ function evictVocabIfFull() {
   }
 }
 var AUDIT_ACTIONS = ["run"];
-var auditSchema = z18.object({
-  action: z18.enum(AUDIT_ACTIONS).describe(
+var auditSchema = z20.object({
+  action: z20.enum(AUDIT_ACTIONS).describe(
     "'run': run the hygiene audit for a bet entry."
   ),
-  entryId: z18.string().describe("Bet entry ID to audit, e.g. '<PREFIX>-<n>'"),
-  phase: z18.enum(["shaping", "handoff"]).default("shaping").optional().describe(
+  entryId: z20.string().describe("Bet entry ID to audit, e.g. '<PREFIX>-<n>'"),
+  phase: z20.enum(["shaping", "handoff"]).default("shaping").optional().describe(
     "'shaping': check shaping-phase fields only. 'handoff': check all required fields including buildContract/buildSequence/exclusions/risks. Default: shaping."
   )
 });
@@ -11290,35 +11745,35 @@ async function handleAuditRun(entryId, phase) {
 
 // src/tools/quality.ts
 var QUALITY_ACTIONS = ["check", "re-evaluate", "verify-chain", "audit"];
-var qualitySchema = z19.object({
-  action: z19.enum(QUALITY_ACTIONS).describe(
+var qualitySchema = z21.object({
+  action: z21.enum(QUALITY_ACTIONS).describe(
     "'check': read the entry's server quality verdict (tier + criteria). 're-evaluate': trigger fresh evaluation. 'verify-chain': verify entries against the codebase (codeMapping drift, cross-references) \u2014 absorbs `verify`. 'audit': hygiene audit for a bet entry \u2014 absorbs `audit`."
   ),
-  entryId: z19.string().max(200).optional().describe("For 'check'/'re-evaluate'/'audit': entry ID, e.g. 'TEN-graph-db', '<PREFIX>-<n>'."),
-  context: z19.enum(["capture", "commit", "review"]).default("review").optional().describe("For re-evaluate: evaluation context"),
-  collection: z19.string().max(200).optional().describe("For 'verify-chain': collection slug to verify (default: glossary)."),
-  mode: z19.enum(["report", "fix"]).optional().describe("For 'verify-chain': 'report' = read-only trust report (default). 'fix' = also update drifted codeMapping statuses."),
-  phase: z19.enum(["shaping", "handoff"]).optional().describe(
+  entryId: z21.string().max(200).optional().describe("For 'check'/'re-evaluate'/'audit': entry ID, e.g. 'TEN-graph-db', '<PREFIX>-<n>'."),
+  context: z21.enum(["capture", "commit", "review"]).default("review").optional().describe("For re-evaluate: evaluation context"),
+  collection: z21.string().max(200).optional().describe("For 'verify-chain': collection slug to verify (default: glossary)."),
+  mode: z21.enum(["report", "fix"]).optional().describe("For 'verify-chain': 'report' = read-only trust report (default). 'fix' = also update drifted codeMapping statuses."),
+  phase: z21.enum(["shaping", "handoff"]).optional().describe(
     "For 'audit': 'shaping' checks shaping-phase fields only (default). 'handoff' checks all required fields including buildContract/buildSequence/exclusions/risks."
   )
 });
-var qualityCheckVariant = z19.object({ action: z19.literal("check"), entryId: z19.string().max(200) });
-var qualityReEvaluateVariant = z19.object({
-  action: z19.literal("re-evaluate"),
-  entryId: z19.string().max(200),
-  context: z19.enum(["capture", "commit", "review"]).optional().default("review")
+var qualityCheckVariant = z21.object({ action: z21.literal("check"), entryId: z21.string().max(200) });
+var qualityReEvaluateVariant = z21.object({
+  action: z21.literal("re-evaluate"),
+  entryId: z21.string().max(200),
+  context: z21.enum(["capture", "commit", "review"]).optional().default("review")
 });
-var qualityVerifyChainVariant = z19.object({
-  action: z19.literal("verify-chain"),
-  collection: z19.string().max(200).optional().default("glossary"),
-  mode: z19.enum(["report", "fix"]).optional().default("report")
+var qualityVerifyChainVariant = z21.object({
+  action: z21.literal("verify-chain"),
+  collection: z21.string().max(200).optional().default("glossary"),
+  mode: z21.enum(["report", "fix"]).optional().default("report")
 });
-var qualityAuditVariant = z19.object({
-  action: z19.literal("audit"),
-  entryId: z19.string().max(200),
-  phase: z19.enum(["shaping", "handoff"]).optional().default("shaping")
+var qualityAuditVariant = z21.object({
+  action: z21.literal("audit"),
+  entryId: z21.string().max(200),
+  phase: z21.enum(["shaping", "handoff"]).optional().default("shaping")
 });
-var qualityActionUnion = z19.discriminatedUnion("action", [
+var qualityActionUnion = z21.discriminatedUnion("action", [
   qualityCheckVariant,
   qualityReEvaluateVariant,
   qualityVerifyChainVariant,
@@ -11330,27 +11785,27 @@ var QUALITY_ACTION_SPECS = {
   "verify-chain": { params: ["collection", "mode"], description: "All params optional; collection defaults to 'glossary'." },
   audit: { params: ["entryId", "phase"], description: "entryId is required." }
 };
-var qualityCheckOutputSchema = z19.object({
-  entryId: z19.string(),
+var qualityCheckOutputSchema = z21.object({
+  entryId: z21.string(),
   /** WP-480 S1: false = the ID does not resolve to an entry (typo/deleted) — distinct from "no verdict yet". */
-  entryFound: z19.boolean().optional(),
-  hasVerdict: z19.boolean(),
+  entryFound: z21.boolean().optional(),
+  hasVerdict: z21.boolean(),
   /** WP-480 S1: the verdict was judged against content the entry no longer has — re-evaluate for a current one. */
-  stale: z19.boolean().optional(),
-  tier: z19.string().optional(),
-  passed: z19.boolean().optional(),
-  criteria: z19.array(z19.object({
-    id: z19.string(),
-    passed: z19.boolean(),
-    hint: z19.string().optional()
+  stale: z21.boolean().optional(),
+  tier: z21.string().optional(),
+  passed: z21.boolean().optional(),
+  criteria: z21.array(z21.object({
+    id: z21.string(),
+    passed: z21.boolean(),
+    hint: z21.string().optional()
   }))
 });
-var qualityReevaluateOutputSchema = z19.object({
-  entryId: z19.string(),
-  context: z19.string(),
-  score: z19.number(),
-  maxScore: z19.number(),
-  improved: z19.boolean()
+var qualityReevaluateOutputSchema = z21.object({
+  entryId: z21.string(),
+  context: z21.string(),
+  score: z21.number(),
+  maxScore: z21.number(),
+  improved: z21.boolean()
 });
 function registerQualityTools(server) {
   const qualityHandlers = {
@@ -11531,10 +11986,10 @@ async function handleReEvaluate(entryId, context) {
 }
 
 // src/tools/session.ts
-import { z as z22 } from "zod/v3";
+import { z as z24 } from "zod/v3";
 
 // src/tools/wrapup.ts
-import { z as z20 } from "zod/v3";
+import { z as z22 } from "zod/v3";
 
 // src/lib/compose-wrapup-view.ts
 function toComposed(e) {
@@ -11987,8 +12442,8 @@ async function runWrapupCommitAll(data, cachedSuggestions) {
     overflowUnscanned
   };
 }
-var wrapupSchema = z20.object({
-  action: z20.enum(["review", "commit-all"]).optional().describe(
+var wrapupSchema = z22.object({
+  action: z22.enum(["review", "commit-all"]).optional().describe(
     "Action to perform. 'review' (default) shows the wrapup summary. 'commit-all' accepts all uncommitted drafts and creates suggested links."
   )
 });
@@ -12089,26 +12544,26 @@ ${text}` : text;
 }
 
 // src/tools/facilitate.ts
-import { z as z21 } from "zod/v3";
+import { z as z23 } from "zod/v3";
 var FACILITATE_ACTIONS = ["resume", "commit-constellation"];
-var coherencyAcknowledgementSchema = z21.object({
-  response: z21.string().max(200).describe("Acknowledgement response per offender: 'linked' | 'accepted-fix' | 'diverged'."),
-  entryId: z21.string().max(200).optional().describe("Entry the acknowledgement links to (e.g. the strategic spine entry)."),
-  reason: z21.string().max(2e3).optional().describe("Free-text justification, required for a 'diverged' response."),
-  subjectEntryId: z21.string().max(200).optional().describe("The refused entry this acknowledgement answers.")
+var coherencyAcknowledgementSchema = z23.object({
+  response: z23.string().max(200).describe("Acknowledgement response per offender: 'linked' | 'accepted-fix' | 'diverged'."),
+  entryId: z23.string().max(200).optional().describe("Entry the acknowledgement links to (e.g. the strategic spine entry)."),
+  reason: z23.string().max(2e3).optional().describe("Free-text justification, required for a 'diverged' response."),
+  subjectEntryId: z23.string().max(200).optional().describe("The refused entry this acknowledgement answers.")
 });
-var facilitateSchema = z21.object({
-  action: z21.enum(FACILITATE_ACTIONS).describe(
+var facilitateSchema = z23.object({
+  action: z23.enum(FACILITATE_ACTIONS).describe(
     "'resume': load session state from an existing bet entry. 'commit-constellation': atomically accept a bet and all its linked draft entries in one call. Requires betEntryId."
   ),
-  betEntryId: z21.string().max(200).optional().describe("Bet entry ID. Required for both actions."),
-  operationId: z21.string().max(200).optional().describe("Optional idempotency key for commit-constellation retries."),
+  betEntryId: z23.string().max(200).optional().describe("Bet entry ID. Required for both actions."),
+  operationId: z23.string().max(200).optional().describe("Optional idempotency key for commit-constellation retries."),
   // WP-465 slice ⑤: coherency retry controls for a COHERENCY_REFUSED constellation hold.
   // Forwarded verbatim to agentKnowledge.facilitateEnvelope (validation lives at the gate).
-  coherencyAcknowledgements: z21.array(coherencyAcknowledgementSchema).max(20).optional().describe(
+  coherencyAcknowledgements: z23.array(coherencyAcknowledgementSchema).max(20).optional().describe(
     "Per-offender acknowledgements to retry a constellation held under standard/strict coherency mode. Each: {subjectEntryId, response: 'linked' | 'accepted-fix' | 'diverged', entryId?, reason?}."
   ),
-  steeringOverrideReason: z21.string().max(2e3).optional().describe(
+  steeringOverrideReason: z23.string().max(2e3).optional().describe(
     "Typed override reason (>= 12 chars) to push a constellation past a coherency hold instead of acknowledging."
   )
 });
@@ -12361,33 +12816,33 @@ var SESSION_ACTIONS = [
   "resume",
   "commit-constellation"
 ];
-var coherencyAcknowledgementFlatSchema2 = z22.object({
-  response: z22.string().max(200).describe("Acknowledgement response per offender: 'linked' | 'accepted-fix' | 'diverged'."),
-  entryId: z22.string().max(200).optional().describe("Entry the acknowledgement links to."),
-  reason: z22.string().max(2e3).optional().describe("Free-text justification, required for a 'diverged' response."),
-  subjectEntryId: z22.string().max(200).optional().describe("The refused entry this acknowledgement answers.")
+var coherencyAcknowledgementFlatSchema2 = z24.object({
+  response: z24.string().max(200).describe("Acknowledgement response per offender: 'linked' | 'accepted-fix' | 'diverged'."),
+  entryId: z24.string().max(200).optional().describe("Entry the acknowledgement links to."),
+  reason: z24.string().max(2e3).optional().describe("Free-text justification, required for a 'diverged' response."),
+  subjectEntryId: z24.string().max(200).optional().describe("The refused entry this acknowledgement answers.")
 });
-var sessionSchema = z22.object({
-  action: z22.enum(SESSION_ACTIONS).describe(
+var sessionSchema = z24.object({
+  action: z24.enum(SESSION_ACTIONS).describe(
     "'start': begin a tracked session. 'close': end the session and record activity. 'status': check current session state. 'wrapup-review': review uncommitted drafts before closing (absorbs session-wrapup action=review). 'wrapup-commit': accept all uncommitted drafts (absorbs session-wrapup action=commit-all). 'resume': load session state from an existing bet entry (absorbs facilitate action=resume). 'commit-constellation': atomically accept a bet and its linked drafts (absorbs facilitate action=commit-constellation)."
   ),
-  betEntryId: z22.string().max(200).optional().describe("For 'resume'/'commit-constellation': bet entry ID. Required for both."),
-  operationId: z22.string().max(200).optional().describe("For 'commit-constellation': optional idempotency key for retries."),
-  coherencyAcknowledgements: z22.array(coherencyAcknowledgementFlatSchema2).max(20).optional().describe(
+  betEntryId: z24.string().max(200).optional().describe("For 'resume'/'commit-constellation': bet entry ID. Required for both."),
+  operationId: z24.string().max(200).optional().describe("For 'commit-constellation': optional idempotency key for retries."),
+  coherencyAcknowledgements: z24.array(coherencyAcknowledgementFlatSchema2).max(20).optional().describe(
     "For 'commit-constellation': per-offender acknowledgements to retry a constellation held under standard/strict coherency mode."
   ),
-  steeringOverrideReason: z22.string().max(2e3).optional().describe(
+  steeringOverrideReason: z24.string().max(2e3).optional().describe(
     "For 'commit-constellation': typed override reason (>= 12 chars) to push past a coherency hold instead of acknowledging."
   )
 });
-var sessionStartVariant = z22.object({ action: z22.literal("start") });
-var sessionCloseVariant = z22.object({ action: z22.literal("close") });
-var sessionStatusVariant = z22.object({ action: z22.literal("status") });
-var sessionWrapupReviewVariant = z22.object({ action: z22.literal("wrapup-review") });
-var sessionWrapupCommitVariant = z22.object({ action: z22.literal("wrapup-commit") });
-var sessionResumeVariant = facilitateSchema.omit({ action: true }).extend({ action: z22.literal("resume") });
-var sessionCommitConstellationVariant = facilitateSchema.omit({ action: true }).extend({ action: z22.literal("commit-constellation") });
-var sessionActionUnion = z22.discriminatedUnion("action", [
+var sessionStartVariant = z24.object({ action: z24.literal("start") });
+var sessionCloseVariant = z24.object({ action: z24.literal("close") });
+var sessionStatusVariant = z24.object({ action: z24.literal("status") });
+var sessionWrapupReviewVariant = z24.object({ action: z24.literal("wrapup-review") });
+var sessionWrapupCommitVariant = z24.object({ action: z24.literal("wrapup-commit") });
+var sessionResumeVariant = facilitateSchema.omit({ action: true }).extend({ action: z24.literal("resume") });
+var sessionCommitConstellationVariant = facilitateSchema.omit({ action: true }).extend({ action: z24.literal("commit-constellation") });
+var sessionActionUnion = z24.discriminatedUnion("action", [
   sessionStartVariant,
   sessionCloseVariant,
   sessionStatusVariant,
@@ -12611,7 +13066,7 @@ async function handleStatus() {
 }
 
 // src/tools/gitchain.ts
-import { z as z23 } from "zod/v3";
+import { z as z25 } from "zod/v3";
 
 // src/lib/versionDisplay.ts
 function toVersionDisplay(version) {
@@ -12620,51 +13075,51 @@ function toVersionDisplay(version) {
 }
 
 // src/tools/gitchain.ts
-var chainSchema = z23.object({
-  action: z23.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
-  chainEntryId: z23.string().max(200).optional().describe("Chain entry ID (required for get/edit)"),
-  title: z23.string().max(500).optional().describe("Process title (required for create)"),
-  chainTypeId: z23.string().max(200).optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
-  description: z23.string().max(2e4).optional().describe("Description (for create)"),
-  linkId: z23.string().max(200).optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
-  content: z23.string().max(5e4).optional().describe("New content for the link (for edit action)"),
-  status: z23.string().max(200).optional().describe("Filter by status for list: 'draft' or 'active'"),
-  author: z23.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'."),
+var chainSchema = z25.object({
+  action: z25.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
+  chainEntryId: z25.string().max(200).optional().describe("Chain entry ID (required for get/edit)"),
+  title: z25.string().max(500).optional().describe("Process title (required for create)"),
+  chainTypeId: z25.string().max(200).optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
+  description: z25.string().max(2e4).optional().describe("Description (for create)"),
+  linkId: z25.string().max(200).optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
+  content: z25.string().max(5e4).optional().describe("New content for the link (for edit action)"),
+  status: z25.string().max(200).optional().describe("Filter by status for list: 'draft' or 'active'"),
+  author: z25.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'."),
   // WP-513 review round 3 (P1): team+role to create AS OWNER of (rung 2 only) — entry ID or entryId (e.g. "TEAM-1").
-  ownerTeamEntryId: z23.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
-  ownerRoleEntryId: z23.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
+  ownerTeamEntryId: z25.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
+  ownerRoleEntryId: z25.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
 });
-var chainVersionSchema = z23.object({
-  action: z23.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
-  chainEntryId: z23.string().max(200).describe("The chain's entry ID"),
-  commitMessage: z23.string().max(2e3).optional().describe("Commit message (required for commit). Convention: type(link): description"),
-  versionA: z23.number().optional().describe("Earlier version for diff"),
-  versionB: z23.number().optional().describe("Later version for diff"),
-  toVersion: z23.number().optional().describe("Version number to revert to"),
-  author: z23.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+var chainVersionSchema = z25.object({
+  action: z25.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
+  chainEntryId: z25.string().max(200).describe("The chain's entry ID"),
+  commitMessage: z25.string().max(2e3).optional().describe("Commit message (required for commit). Convention: type(link): description"),
+  versionA: z25.number().optional().describe("Earlier version for diff"),
+  versionB: z25.number().optional().describe("Later version for diff"),
+  toVersion: z25.number().optional().describe("Version number to revert to"),
+  author: z25.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainBranchSchema = z23.object({
-  action: z23.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
-  chainEntryId: z23.string().max(200).describe("The chain's entry ID"),
-  branchName: z23.string().max(200).optional().describe("Branch name (required for merge/conflicts, optional for create)"),
-  strategy: z23.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
-  author: z23.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+var chainBranchSchema = z25.object({
+  action: z25.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
+  chainEntryId: z25.string().max(200).describe("The chain's entry ID"),
+  branchName: z25.string().max(200).optional().describe("Branch name (required for merge/conflicts, optional for create)"),
+  strategy: z25.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
+  author: z25.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainReviewSchema = z23.object({
-  action: z23.enum(["gate", "comment", "resolve-comment", "list-comments"]).describe("Action: run coherence gate, add a comment, resolve a comment, or list comments"),
+var chainReviewSchema = z25.object({
+  action: z25.enum(["gate", "comment", "resolve-comment", "list-comments"]).describe("Action: run coherence gate, add a comment, resolve a comment, or list comments"),
   // Finding #12: optional at the base (mirrors chainSchema's chainEntryId pattern at
   // line ~690) — resolve-comment resolves purely by commentId (handleChainReview never
   // reads chainEntryId in that branch) and the compound-tool's advertised schema
   // (chainReviewCompoundSchema below) already documents it as optional for that action.
   // Per-action variants that DO need it (gate/comment/list-comments) re-require it below,
   // same pattern as chainGetVariant/chainEditVariant re-requiring over chainSchema's base.
-  chainEntryId: z23.string().max(200).optional().describe("The chain's entry ID. Required for every action except 'resolve-comment'."),
-  commitMessage: z23.string().max(2e3).optional().describe("Commit message to lint (for gate action)"),
-  versionNumber: z23.number().optional().describe("Version to comment on or list comments for"),
-  linkId: z23.string().max(200).optional().describe("Link this comment targets (optional for comment)"),
-  body: z23.string().max(2e4).optional().describe("Comment text (required for comment action)"),
-  commentId: z23.string().max(200).optional().describe("Comment ID (required for resolve-comment)"),
-  author: z23.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+  chainEntryId: z25.string().max(200).optional().describe("The chain's entry ID. Required for every action except 'resolve-comment'."),
+  commitMessage: z25.string().max(2e3).optional().describe("Commit message to lint (for gate action)"),
+  versionNumber: z25.number().optional().describe("Version to comment on or list comments for"),
+  linkId: z25.string().max(200).optional().describe("Link this comment targets (optional for comment)"),
+  body: z25.string().max(2e4).optional().describe("Comment text (required for comment action)"),
+  commentId: z25.string().max(200).optional().describe("Comment ID (required for resolve-comment)"),
+  author: z25.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
 function linkSummary(links) {
   return Object.entries(links).map(([id, content]) => {
@@ -13169,57 +13624,57 @@ var CHAIN_REVIEW_ACTIONS = [
   "branch.merge",
   "branch.conflicts"
 ];
-var chainCompoundSchema = z23.object({
-  action: z23.enum(CHAIN_ACTIONS).describe(
+var chainCompoundSchema = z25.object({
+  action: z25.enum(CHAIN_ACTIONS).describe(
     "Unnamespaced: 'create'/'get'/'list'/'edit' \u2014 process CRUD (the original `chain` tool). 'version.*' (commit/list/diff/revert/history) \u2014 versioning, absorbs `chain-version`. Branching and review live on the sibling `chain-review` tool."
   ),
-  chainEntryId: z23.string().max(200).optional().describe("Chain entry ID. Required for get/edit and all version.* actions."),
-  title: z23.string().max(500).optional().describe("For 'create': process title (required)."),
-  chainTypeId: z23.string().max(200).optional().default("strategy-coherence").describe("For 'create'/'list': process template slug."),
-  description: z23.string().max(2e4).optional().describe("For 'create': description."),
-  linkId: z23.string().max(200).optional().describe("For 'edit': link to edit (required)."),
-  content: z23.string().max(5e4).optional().describe("For 'edit': new content for the link (required)."),
-  status: z23.string().max(200).optional().describe("For 'list': filter by status."),
-  author: z23.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'."),
-  commitMessage: z23.string().max(2e3).optional().describe("For 'version.commit': commit message (required)."),
-  versionA: z23.number().optional().describe("For 'version.diff': earlier version (required)."),
-  versionB: z23.number().optional().describe("For 'version.diff': later version (required)."),
-  toVersion: z23.number().optional().describe("For 'version.revert': version number to revert to (required)."),
+  chainEntryId: z25.string().max(200).optional().describe("Chain entry ID. Required for get/edit and all version.* actions."),
+  title: z25.string().max(500).optional().describe("For 'create': process title (required)."),
+  chainTypeId: z25.string().max(200).optional().default("strategy-coherence").describe("For 'create'/'list': process template slug."),
+  description: z25.string().max(2e4).optional().describe("For 'create': description."),
+  linkId: z25.string().max(200).optional().describe("For 'edit': link to edit (required)."),
+  content: z25.string().max(5e4).optional().describe("For 'edit': new content for the link (required)."),
+  status: z25.string().max(200).optional().describe("For 'list': filter by status."),
+  author: z25.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'."),
+  commitMessage: z25.string().max(2e3).optional().describe("For 'version.commit': commit message (required)."),
+  versionA: z25.number().optional().describe("For 'version.diff': earlier version (required)."),
+  versionB: z25.number().optional().describe("For 'version.diff': later version (required)."),
+  toVersion: z25.number().optional().describe("For 'version.revert': version number to revert to (required)."),
   // WP-513 review round 3 (P1): team+role to create AS OWNER of (rung 2 only).
-  ownerTeamEntryId: z23.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
-  ownerRoleEntryId: z23.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
+  ownerTeamEntryId: z25.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
+  ownerRoleEntryId: z25.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
 });
-var chainReviewCompoundSchema = z23.object({
-  action: z23.enum(CHAIN_REVIEW_ACTIONS).describe(
+var chainReviewCompoundSchema = z25.object({
+  action: z25.enum(CHAIN_REVIEW_ACTIONS).describe(
     "'gate'/'comment'/'resolve-comment'/'list-comments' \u2014 quality gate + comments (the original `chain-review` tool, unchanged call shape). 'branch.*' (create/list/merge/conflicts) \u2014 branching, absorbs `chain-branch`. Process CRUD and versioning live on the sibling `chain` tool."
   ),
-  chainEntryId: z23.string().max(200).optional().describe("Chain entry ID. Required for every action except 'resolve-comment'."),
-  commitMessage: z23.string().max(2e3).optional().describe("For 'gate': commit message to lint."),
-  versionNumber: z23.number().optional().describe("For 'comment'/'list-comments': version to comment on or list comments for."),
-  linkId: z23.string().max(200).optional().describe("For 'comment': optional link this comment targets."),
-  body: z23.string().max(2e4).optional().describe("For 'comment': comment text (required)."),
-  commentId: z23.string().max(200).optional().describe("For 'resolve-comment': comment ID (required)."),
-  branchName: z23.string().max(200).optional().describe("For 'branch.merge'/'branch.conflicts': required. For 'branch.create': optional."),
-  strategy: z23.enum(["merge_commit", "squash"]).optional().describe("For 'branch.merge': merge strategy. Default 'merge_commit'."),
-  author: z23.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+  chainEntryId: z25.string().max(200).optional().describe("Chain entry ID. Required for every action except 'resolve-comment'."),
+  commitMessage: z25.string().max(2e3).optional().describe("For 'gate': commit message to lint."),
+  versionNumber: z25.number().optional().describe("For 'comment'/'list-comments': version to comment on or list comments for."),
+  linkId: z25.string().max(200).optional().describe("For 'comment': optional link this comment targets."),
+  body: z25.string().max(2e4).optional().describe("For 'comment': comment text (required)."),
+  commentId: z25.string().max(200).optional().describe("For 'resolve-comment': comment ID (required)."),
+  branchName: z25.string().max(200).optional().describe("For 'branch.merge'/'branch.conflicts': required. For 'branch.create': optional."),
+  strategy: z25.enum(["merge_commit", "squash"]).optional().describe("For 'branch.merge': merge strategy. Default 'merge_commit'."),
+  author: z25.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainCreateVariant = chainSchema.omit({ action: true }).extend({ action: z23.literal("create") });
-var chainGetVariant = z23.object({ action: z23.literal("get"), chainEntryId: z23.string().max(200) });
-var chainListVariant = z23.object({ action: z23.literal("list"), chainTypeId: z23.string().max(200).optional(), status: z23.string().max(200).optional() });
-var chainEditVariant = z23.object({
-  action: z23.literal("edit"),
-  chainEntryId: z23.string().max(200),
-  linkId: z23.string().max(200),
-  content: z23.string().max(5e4),
-  author: z23.string().max(200).optional()
+var chainCreateVariant = chainSchema.omit({ action: true }).extend({ action: z25.literal("create") });
+var chainGetVariant = z25.object({ action: z25.literal("get"), chainEntryId: z25.string().max(200) });
+var chainListVariant = z25.object({ action: z25.literal("list"), chainTypeId: z25.string().max(200).optional(), status: z25.string().max(200).optional() });
+var chainEditVariant = z25.object({
+  action: z25.literal("edit"),
+  chainEntryId: z25.string().max(200),
+  linkId: z25.string().max(200),
+  content: z25.string().max(5e4),
+  author: z25.string().max(200).optional()
 });
 var versionBase = chainVersionSchema.omit({ action: true });
-var chainVersionCommitVariant = versionBase.extend({ action: z23.literal("version.commit"), commitMessage: z23.string().max(2e3) });
-var chainVersionListVariant = versionBase.extend({ action: z23.literal("version.list") });
-var chainVersionDiffVariant = versionBase.extend({ action: z23.literal("version.diff"), versionA: z23.number(), versionB: z23.number() });
-var chainVersionRevertVariant = versionBase.extend({ action: z23.literal("version.revert"), toVersion: z23.number() });
-var chainVersionHistoryVariant = versionBase.extend({ action: z23.literal("version.history") });
-var chainActionUnion = z23.discriminatedUnion("action", [
+var chainVersionCommitVariant = versionBase.extend({ action: z25.literal("version.commit"), commitMessage: z25.string().max(2e3) });
+var chainVersionListVariant = versionBase.extend({ action: z25.literal("version.list") });
+var chainVersionDiffVariant = versionBase.extend({ action: z25.literal("version.diff"), versionA: z25.number(), versionB: z25.number() });
+var chainVersionRevertVariant = versionBase.extend({ action: z25.literal("version.revert"), toVersion: z25.number() });
+var chainVersionHistoryVariant = versionBase.extend({ action: z25.literal("version.history") });
+var chainActionUnion = z25.discriminatedUnion("action", [
   chainCreateVariant,
   chainGetVariant,
   chainListVariant,
@@ -13231,16 +13686,16 @@ var chainActionUnion = z23.discriminatedUnion("action", [
   chainVersionHistoryVariant
 ]);
 var reviewBase = chainReviewSchema.omit({ action: true });
-var chainReviewGateVariant = reviewBase.extend({ action: z23.literal("gate"), chainEntryId: z23.string().max(200) });
-var chainReviewCommentVariant = reviewBase.extend({ action: z23.literal("comment"), chainEntryId: z23.string().max(200), versionNumber: z23.number(), body: z23.string().max(2e4) });
-var chainReviewResolveCommentVariant = reviewBase.extend({ action: z23.literal("resolve-comment"), commentId: z23.string().max(200) });
-var chainReviewListCommentsVariant = reviewBase.extend({ action: z23.literal("list-comments"), chainEntryId: z23.string().max(200) });
+var chainReviewGateVariant = reviewBase.extend({ action: z25.literal("gate"), chainEntryId: z25.string().max(200) });
+var chainReviewCommentVariant = reviewBase.extend({ action: z25.literal("comment"), chainEntryId: z25.string().max(200), versionNumber: z25.number(), body: z25.string().max(2e4) });
+var chainReviewResolveCommentVariant = reviewBase.extend({ action: z25.literal("resolve-comment"), commentId: z25.string().max(200) });
+var chainReviewListCommentsVariant = reviewBase.extend({ action: z25.literal("list-comments"), chainEntryId: z25.string().max(200) });
 var branchBase = chainBranchSchema.omit({ action: true });
-var chainBranchCreateVariant = branchBase.extend({ action: z23.literal("branch.create") });
-var chainBranchListVariant = branchBase.extend({ action: z23.literal("branch.list") });
-var chainBranchMergeVariant = branchBase.extend({ action: z23.literal("branch.merge"), branchName: z23.string().max(200) });
-var chainBranchConflictsVariant = branchBase.extend({ action: z23.literal("branch.conflicts"), branchName: z23.string().max(200) });
-var chainReviewActionUnion = z23.discriminatedUnion("action", [
+var chainBranchCreateVariant = branchBase.extend({ action: z25.literal("branch.create") });
+var chainBranchListVariant = branchBase.extend({ action: z25.literal("branch.list") });
+var chainBranchMergeVariant = branchBase.extend({ action: z25.literal("branch.merge"), branchName: z25.string().max(200) });
+var chainBranchConflictsVariant = branchBase.extend({ action: z25.literal("branch.conflicts"), branchName: z25.string().max(200) });
+var chainReviewActionUnion = z25.discriminatedUnion("action", [
   chainReviewGateVariant,
   chainReviewCommentVariant,
   chainReviewResolveCommentVariant,
@@ -13332,44 +13787,44 @@ function registerGitChainTools(server) {
 }
 
 // src/tools/maps.ts
-import { z as z24 } from "zod/v3";
-var createAudienceMapSetSchema = z24.object({
-  audienceEntryId: z24.string().max(200).describe("Entry ID of the audience (e.g. STR-fb7hje)"),
+import { z as z26 } from "zod/v3";
+var createAudienceMapSetSchema = z26.object({
+  audienceEntryId: z26.string().max(200).describe("Entry ID of the audience (e.g. STR-fb7hje)"),
   // WP-513: team+role to create AS OWNER of (rung 2); ID or entryId (e.g. "TEAM-1"); no-op pre-rung-2.
-  ownerTeamEntryId: z24.string().max(200).optional().describe("Team entry ID/ref to own the created maps (required once the workspace is on rung 2)"),
-  ownerRoleEntryId: z24.string().max(200).optional().describe("Role entry ID/ref to own the created maps (required once the workspace is on rung 2)")
+  ownerTeamEntryId: z26.string().max(200).optional().describe("Team entry ID/ref to own the created maps (required once the workspace is on rung 2)"),
+  ownerRoleEntryId: z26.string().max(200).optional().describe("Role entry ID/ref to own the created maps (required once the workspace is on rung 2)")
 });
-var mapSchema = z24.object({
-  action: z24.enum(["create", "get", "list"]).describe("Action: create a map, get map details, or list all maps"),
-  mapEntryId: z24.string().max(200).optional().describe("Map entry ID (for get)"),
-  title: z24.string().max(500).optional().describe("Map title (for create)"),
-  templateId: z24.string().max(200).optional().default("lean-canvas").describe("Template slug for create: 'lean-canvas' or any composed template"),
-  description: z24.string().max(2e4).optional().describe("Description (for create)"),
-  slotIds: z24.array(z24.string().max(200)).max(200).optional().describe("Slot IDs to initialize (for create; auto-populated from template if omitted)"),
-  status: z24.string().max(200).optional().describe("Filter by status for list"),
+var mapSchema = z26.object({
+  action: z26.enum(["create", "get", "list"]).describe("Action: create a map, get map details, or list all maps"),
+  mapEntryId: z26.string().max(200).optional().describe("Map entry ID (for get)"),
+  title: z26.string().max(500).optional().describe("Map title (for create)"),
+  templateId: z26.string().max(200).optional().default("lean-canvas").describe("Template slug for create: 'lean-canvas' or any composed template"),
+  description: z26.string().max(2e4).optional().describe("Description (for create)"),
+  slotIds: z26.array(z26.string().max(200)).max(200).optional().describe("Slot IDs to initialize (for create; auto-populated from template if omitted)"),
+  status: z26.string().max(200).optional().describe("Filter by status for list"),
   // WP-513: team+role to create AS OWNER of (rung 2, action "create" only); no-op pre-rung-2.
-  ownerTeamEntryId: z24.string().max(200).optional().describe("Team entry ID/ref to own the created map (required once the workspace is on rung 2)"),
-  ownerRoleEntryId: z24.string().max(200).optional().describe("Role entry ID/ref to own the created map (required once the workspace is on rung 2)")
+  ownerTeamEntryId: z26.string().max(200).optional().describe("Team entry ID/ref to own the created map (required once the workspace is on rung 2)"),
+  ownerRoleEntryId: z26.string().max(200).optional().describe("Role entry ID/ref to own the created map (required once the workspace is on rung 2)")
 });
-var mapSlotSchema = z24.object({
-  action: z24.enum(["add", "remove", "replace", "list"]).describe("Action: add/remove/replace an ingredient in a slot, or list slot contents"),
-  mapEntryId: z24.string().max(200).describe("Map entry ID"),
-  slotId: z24.string().max(200).optional().describe("Slot ID (e.g. 'problem', 'customer-segments')"),
-  ingredientEntryId: z24.string().max(200).optional().describe("Ingredient entry ID to add/remove"),
-  newIngredientEntryId: z24.string().max(200).optional().describe("New ingredient entry ID (for replace)"),
-  label: z24.string().max(500).optional().describe("Display label override"),
-  author: z24.string().max(200).optional().describe("Who is performing the action")
+var mapSlotSchema = z26.object({
+  action: z26.enum(["add", "remove", "replace", "list"]).describe("Action: add/remove/replace an ingredient in a slot, or list slot contents"),
+  mapEntryId: z26.string().max(200).describe("Map entry ID"),
+  slotId: z26.string().max(200).optional().describe("Slot ID (e.g. 'problem', 'customer-segments')"),
+  ingredientEntryId: z26.string().max(200).optional().describe("Ingredient entry ID to add/remove"),
+  newIngredientEntryId: z26.string().max(200).optional().describe("New ingredient entry ID (for replace)"),
+  label: z26.string().max(500).optional().describe("Display label override"),
+  author: z26.string().max(200).optional().describe("Who is performing the action")
 });
-var mapVersionSchema = z24.object({
-  action: z24.enum(["commit", "list", "history"]).describe("Action: commit the map, list commits, or view commit history"),
-  mapEntryId: z24.string().max(200).describe("Map entry ID"),
-  commitMessage: z24.string().max(2e3).optional().describe("Commit message (for commit action)"),
-  author: z24.string().max(200).optional().describe("Who is committing")
+var mapVersionSchema = z26.object({
+  action: z26.enum(["commit", "list", "history"]).describe("Action: commit the map, list commits, or view commit history"),
+  mapEntryId: z26.string().max(200).describe("Map entry ID"),
+  commitMessage: z26.string().max(2e3).optional().describe("Commit message (for commit action)"),
+  author: z26.string().max(200).optional().describe("Who is committing")
 });
-var mapSuggestSchema = z24.object({
-  mapEntryId: z24.string().max(200).describe("Map entry ID to suggest ingredients for"),
-  slotId: z24.string().max(200).optional().describe("Specific slot to find ingredients for (or all empty slots)"),
-  query: z24.string().max(500).optional().describe("Optional search query to narrow ingredient suggestions")
+var mapSuggestSchema = z26.object({
+  mapEntryId: z26.string().max(200).describe("Map entry ID to suggest ingredients for"),
+  slotId: z26.string().max(200).optional().describe("Specific slot to find ingredients for (or all empty slots)"),
+  query: z26.string().max(500).optional().describe("Optional search query to narrow ingredient suggestions")
 });
 function slotSummary(slots) {
   return Object.entries(slots).map(([id, refs]) => {
@@ -13749,43 +14204,43 @@ var MAP_ACTIONS = [
   "suggest",
   "create-audience-set"
 ];
-var mapCompoundSchema = z24.object({
-  action: z24.enum(MAP_ACTIONS).describe(
+var mapCompoundSchema = z26.object({
+  action: z26.enum(MAP_ACTIONS).describe(
     "Unnamespaced: 'create'/'get'/'list' \u2014 map CRUD (the original `map` tool). 'slot.*' (add/remove/replace/list) \u2014 ingredient slot management, absorbs `map-slot`. 'version.*' (commit/list/history) \u2014 versioning, absorbs `map-version`. 'suggest' \u2014 find ingredients to fill empty slots, absorbs `map-suggest`. 'create-audience-set' \u2014 create all three audience intelligence maps at once, absorbs `create-audience-map-set`."
   ),
-  mapEntryId: z24.string().max(200).optional().describe("Map entry ID. Required for get and all slot.*/version.*/suggest actions."),
-  title: z24.string().max(500).optional().describe("For 'create': map title (required)."),
-  templateId: z24.string().max(200).optional().default("lean-canvas").describe("For 'create': template slug."),
-  description: z24.string().max(2e4).optional().describe("For 'create': description."),
-  slotIds: z24.array(z24.string().max(200)).max(200).optional().describe("For 'create': slot IDs to initialize."),
-  status: z24.string().max(200).optional().describe("For 'list': filter by status."),
-  slotId: z24.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': slot ID (required). For 'suggest': specific slot (optional)."),
-  ingredientEntryId: z24.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': ingredient entry ID to add/remove (required)."),
-  newIngredientEntryId: z24.string().max(200).optional().describe("For 'slot.replace': new ingredient entry ID (required)."),
-  label: z24.string().max(500).optional().describe("For 'slot.add'/'slot.replace': display label override."),
-  author: z24.string().max(200).optional().describe("Who is performing the action."),
-  commitMessage: z24.string().max(2e3).optional().describe("For 'version.commit': commit message."),
-  query: z24.string().max(500).optional().describe("For 'suggest': search query to narrow ingredient suggestions."),
-  audienceEntryId: z24.string().max(200).optional().describe("For 'create-audience-set': audience entry ID (required)."),
+  mapEntryId: z26.string().max(200).optional().describe("Map entry ID. Required for get and all slot.*/version.*/suggest actions."),
+  title: z26.string().max(500).optional().describe("For 'create': map title (required)."),
+  templateId: z26.string().max(200).optional().default("lean-canvas").describe("For 'create': template slug."),
+  description: z26.string().max(2e4).optional().describe("For 'create': description."),
+  slotIds: z26.array(z26.string().max(200)).max(200).optional().describe("For 'create': slot IDs to initialize."),
+  status: z26.string().max(200).optional().describe("For 'list': filter by status."),
+  slotId: z26.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': slot ID (required). For 'suggest': specific slot (optional)."),
+  ingredientEntryId: z26.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': ingredient entry ID to add/remove (required)."),
+  newIngredientEntryId: z26.string().max(200).optional().describe("For 'slot.replace': new ingredient entry ID (required)."),
+  label: z26.string().max(500).optional().describe("For 'slot.add'/'slot.replace': display label override."),
+  author: z26.string().max(200).optional().describe("Who is performing the action."),
+  commitMessage: z26.string().max(2e3).optional().describe("For 'version.commit': commit message."),
+  query: z26.string().max(500).optional().describe("For 'suggest': search query to narrow ingredient suggestions."),
+  audienceEntryId: z26.string().max(200).optional().describe("For 'create-audience-set': audience entry ID (required)."),
   // WP-513 review round 3 (P1): without these here, zod strips them before mapActionUnion ever sees them.
-  ownerTeamEntryId: z24.string().max(200).optional().describe("For 'create'/'create-audience-set': owning team (rung-2 workspaces)."),
-  ownerRoleEntryId: z24.string().max(200).optional().describe("For 'create'/'create-audience-set': owning role (rung-2 workspaces).")
+  ownerTeamEntryId: z26.string().max(200).optional().describe("For 'create'/'create-audience-set': owning team (rung-2 workspaces)."),
+  ownerRoleEntryId: z26.string().max(200).optional().describe("For 'create'/'create-audience-set': owning role (rung-2 workspaces).")
 });
-var mapCreateVariant = mapSchema.omit({ action: true }).extend({ action: z24.literal("create") });
-var mapGetVariant = z24.object({ action: z24.literal("get"), mapEntryId: z24.string().max(200) });
-var mapListVariant = z24.object({ action: z24.literal("list"), templateId: z24.string().max(200).optional(), status: z24.string().max(200).optional() });
+var mapCreateVariant = mapSchema.omit({ action: true }).extend({ action: z26.literal("create") });
+var mapGetVariant = z26.object({ action: z26.literal("get"), mapEntryId: z26.string().max(200) });
+var mapListVariant = z26.object({ action: z26.literal("list"), templateId: z26.string().max(200).optional(), status: z26.string().max(200).optional() });
 var slotBase = mapSlotSchema.omit({ action: true });
-var mapSlotAddVariant = slotBase.extend({ action: z24.literal("slot.add"), slotId: z24.string().max(200), ingredientEntryId: z24.string().max(200) });
-var mapSlotRemoveVariant = slotBase.extend({ action: z24.literal("slot.remove"), slotId: z24.string().max(200), ingredientEntryId: z24.string().max(200) });
-var mapSlotReplaceVariant = slotBase.extend({ action: z24.literal("slot.replace"), slotId: z24.string().max(200), ingredientEntryId: z24.string().max(200), newIngredientEntryId: z24.string().max(200) });
-var mapSlotListVariant = slotBase.extend({ action: z24.literal("slot.list") });
+var mapSlotAddVariant = slotBase.extend({ action: z26.literal("slot.add"), slotId: z26.string().max(200), ingredientEntryId: z26.string().max(200) });
+var mapSlotRemoveVariant = slotBase.extend({ action: z26.literal("slot.remove"), slotId: z26.string().max(200), ingredientEntryId: z26.string().max(200) });
+var mapSlotReplaceVariant = slotBase.extend({ action: z26.literal("slot.replace"), slotId: z26.string().max(200), ingredientEntryId: z26.string().max(200), newIngredientEntryId: z26.string().max(200) });
+var mapSlotListVariant = slotBase.extend({ action: z26.literal("slot.list") });
 var versionBase2 = mapVersionSchema.omit({ action: true });
-var mapVersionCommitVariant = versionBase2.extend({ action: z24.literal("version.commit") });
-var mapVersionListVariant = versionBase2.extend({ action: z24.literal("version.list") });
-var mapVersionHistoryVariant = versionBase2.extend({ action: z24.literal("version.history") });
-var mapSuggestVariant = mapSuggestSchema.extend({ action: z24.literal("suggest") });
-var mapCreateAudienceSetVariant = createAudienceMapSetSchema.extend({ action: z24.literal("create-audience-set") });
-var mapActionUnion = z24.discriminatedUnion("action", [
+var mapVersionCommitVariant = versionBase2.extend({ action: z26.literal("version.commit") });
+var mapVersionListVariant = versionBase2.extend({ action: z26.literal("version.list") });
+var mapVersionHistoryVariant = versionBase2.extend({ action: z26.literal("version.history") });
+var mapSuggestVariant = mapSuggestSchema.extend({ action: z26.literal("suggest") });
+var mapCreateAudienceSetVariant = createAudienceMapSetSchema.extend({ action: z26.literal("create-audience-set") });
+var mapActionUnion = z26.discriminatedUnion("action", [
   mapCreateVariant,
   mapGetVariant,
   mapListVariant,
@@ -13849,10 +14304,10 @@ function registerMapTools(server) {
 }
 
 // src/tools/workspace.ts
-import { z as z27 } from "zod/v3";
+import { z as z29 } from "zod/v3";
 
 // src/tools/health.ts
-import { z as z25 } from "zod/v3";
+import { z as z27 } from "zod/v3";
 var CALL_CATEGORIES = {
   "chain.getEntry": "read",
   "chain.batchGetEntries": "read",
@@ -14197,65 +14652,65 @@ ${logLines.join("\n")}` }],
   };
 }
 var HEALTH_ACTIONS = ["check", "whoami", "status", "audit", "self-test"];
-var healthSchema = z25.object({
-  action: z25.enum(HEALTH_ACTIONS).describe(
+var healthSchema = z27.object({
+  action: z27.enum(HEALTH_ACTIONS).describe(
     "'check': connectivity and workspace stats. 'whoami': session identity. 'status': workspace readiness. 'audit': session audit log. 'self-test': validate all tool schemas."
   ),
-  limit: z25.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
+  limit: z27.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
 });
-var healthCheckOutputSchema = z25.object({
-  healthy: z25.boolean(),
-  collections: z25.number(),
-  entries: z25.number(),
-  latencyMs: z25.number(),
-  workspace: z25.string()
+var healthCheckOutputSchema = z27.object({
+  healthy: z27.boolean(),
+  collections: z27.number(),
+  entries: z27.number(),
+  latencyMs: z27.number(),
+  workspace: z27.string()
 });
-var organisationHealthSchema = z25.object({
-  reviewed: z25.number(),
-  agreements: z25.number(),
-  disagreements: z25.number(),
-  abstentions: z25.number(),
-  agreementRate: z25.number(),
-  flags: z25.array(z25.object({
-    collection: z25.string(),
-    count: z25.number(),
-    suggestedCollection: z25.string()
+var organisationHealthSchema = z27.object({
+  reviewed: z27.number(),
+  agreements: z27.number(),
+  disagreements: z27.number(),
+  abstentions: z27.number(),
+  agreementRate: z27.number(),
+  flags: z27.array(z27.object({
+    collection: z27.string(),
+    count: z27.number(),
+    suggestedCollection: z27.string()
   }))
 });
-var healthStatusOutputSchema = z25.object({
-  stage: z25.enum(["blank", "seeded", "grounded", "connected"]).optional().default("seeded"),
-  scoringVersion: z25.enum(["v1", "v2"]).optional().default("v1"),
-  readinessScore: z25.number(),
-  activeEntries: z25.number(),
-  totalRelations: z25.number(),
-  orphanedEntries: z25.number(),
-  gaps: z25.array(z25.object({ id: z25.string(), label: z25.string(), guidance: z25.string() })),
+var healthStatusOutputSchema = z27.object({
+  stage: z27.enum(["blank", "seeded", "grounded", "connected"]).optional().default("seeded"),
+  scoringVersion: z27.enum(["v1", "v2"]).optional().default("v1"),
+  readinessScore: z27.number(),
+  activeEntries: z27.number(),
+  totalRelations: z27.number(),
+  orphanedEntries: z27.number(),
+  gaps: z27.array(z27.object({ id: z27.string(), label: z27.string(), guidance: z27.string() })),
   organisationHealth: organisationHealthSchema.optional()
 });
-var healthAuditOutputSchema = z25.object({
-  totalCalls: z25.number(),
-  calls: z25.array(z25.object({
-    tool: z25.string(),
-    action: z25.string().optional(),
-    timestamp: z25.string(),
-    durationMs: z25.number().optional()
+var healthAuditOutputSchema = z27.object({
+  totalCalls: z27.number(),
+  calls: z27.array(z27.object({
+    tool: z27.string(),
+    action: z27.string().optional(),
+    timestamp: z27.string(),
+    durationMs: z27.number().optional()
   }))
 });
-var healthWhoamiOutputSchema = z25.object({
-  workspaceId: z25.string(),
-  workspaceName: z25.string(),
-  scope: z25.string(),
-  sessionId: z25.union([z25.string(), z25.null()]),
-  oriented: z25.boolean()
+var healthWhoamiOutputSchema = z27.object({
+  workspaceId: z27.string(),
+  workspaceName: z27.string(),
+  scope: z27.string(),
+  sessionId: z27.union([z27.string(), z27.null()]),
+  oriented: z27.boolean()
 });
-var selfTestOutputSchema = z25.object({
-  passed: z25.number(),
-  failed: z25.number(),
-  total: z25.number(),
-  results: z25.array(z25.object({
-    tool: z25.string(),
-    valid: z25.boolean(),
-    error: z25.string().optional()
+var selfTestOutputSchema = z27.object({
+  passed: z27.number(),
+  failed: z27.number(),
+  total: z27.number(),
+  results: z27.array(z27.object({
+    tool: z27.string(),
+    valid: z27.boolean(),
+    error: z27.string().optional()
   }))
 });
 function handleSelfTest(server) {
@@ -14306,9 +14761,9 @@ function handleSelfTest(server) {
 }
 
 // src/tools/usage.ts
-import { z as z26 } from "zod/v3";
-var usageSummarySchema = z26.object({
-  periodDays: z26.number().min(1).max(90).optional().describe("Number of days to look back (default 30, max 90)")
+import { z as z28 } from "zod/v3";
+var usageSummarySchema = z28.object({
+  periodDays: z28.number().min(1).max(90).optional().describe("Number of days to look back (default 30, max 90)")
 });
 async function handleUsageSummary(periodDays) {
   const ws = await getWorkspaceContext();
@@ -14480,35 +14935,35 @@ var WORKSPACE_ACTIONS = [
   "proposals-respond",
   "proposals-count"
 ];
-var workspaceSchema = z27.object({
-  action: z27.enum(WORKSPACE_ACTIONS).describe(
+var workspaceSchema = z29.object({
+  action: z29.enum(WORKSPACE_ACTIONS).describe(
     "'check': connectivity and workspace stats (absorbs health action=check). 'whoami': session identity (absorbs health action=whoami). 'status': workspace readiness (absorbs health action=status). 'audit': session audit log (absorbs health action=audit). 'self-test': validate all tool schemas (absorbs health action=self-test). 'usage': LLM usage and cost summary (absorbs get-usage-summary). 'proposals-list': list open consent proposals (absorbs governance-proposals action=list). 'proposals-respond': approve/reject a consent proposal (absorbs governance-proposals action=respond). 'proposals-count': count open consent proposals (absorbs governance-proposals action=count)."
   ),
-  limit: z27.number().min(1).max(50).optional().describe("For 'audit': how many recent calls to show (max 50, default 20)."),
-  periodDays: z27.number().min(1).max(90).optional().describe("For 'usage': number of days to look back (default 30, max 90)."),
-  status: z27.enum(["open", "approved", "objected", "expired"]).optional().describe("For 'proposals-list': filter by status (default: open)."),
-  proposalId: z27.string().max(200).optional().describe("For 'proposals-respond': proposal ID."),
-  verdict: z27.enum(["approve", "reject"]).optional().describe("For 'proposals-respond': approve or reject."),
-  reason: z27.string().max(2e3).optional().describe("For 'proposals-respond': reason for the verdict (required when rejecting).")
+  limit: z29.number().min(1).max(50).optional().describe("For 'audit': how many recent calls to show (max 50, default 20)."),
+  periodDays: z29.number().min(1).max(90).optional().describe("For 'usage': number of days to look back (default 30, max 90)."),
+  status: z29.enum(["open", "approved", "objected", "expired"]).optional().describe("For 'proposals-list': filter by status (default: open)."),
+  proposalId: z29.string().max(200).optional().describe("For 'proposals-respond': proposal ID."),
+  verdict: z29.enum(["approve", "reject"]).optional().describe("For 'proposals-respond': approve or reject."),
+  reason: z29.string().max(2e3).optional().describe("For 'proposals-respond': reason for the verdict (required when rejecting).")
 });
-var workspaceCheckVariant = z27.object({ action: z27.literal("check") });
-var workspaceWhoamiVariant = z27.object({ action: z27.literal("whoami") });
-var workspaceStatusVariant = z27.object({ action: z27.literal("status") });
-var workspaceAuditVariant = z27.object({ action: z27.literal("audit"), limit: z27.number().min(1).max(50).optional().default(20) });
-var workspaceSelfTestVariant = z27.object({ action: z27.literal("self-test") });
-var workspaceUsageVariant = z27.object({ action: z27.literal("usage"), periodDays: z27.number().min(1).max(90).optional() });
-var workspaceProposalsListVariant = z27.object({
-  action: z27.literal("proposals-list"),
-  status: z27.enum(["open", "approved", "objected", "expired"]).optional()
+var workspaceCheckVariant = z29.object({ action: z29.literal("check") });
+var workspaceWhoamiVariant = z29.object({ action: z29.literal("whoami") });
+var workspaceStatusVariant = z29.object({ action: z29.literal("status") });
+var workspaceAuditVariant = z29.object({ action: z29.literal("audit"), limit: z29.number().min(1).max(50).optional().default(20) });
+var workspaceSelfTestVariant = z29.object({ action: z29.literal("self-test") });
+var workspaceUsageVariant = z29.object({ action: z29.literal("usage"), periodDays: z29.number().min(1).max(90).optional() });
+var workspaceProposalsListVariant = z29.object({
+  action: z29.literal("proposals-list"),
+  status: z29.enum(["open", "approved", "objected", "expired"]).optional()
 });
-var workspaceProposalsRespondVariant = z27.object({
-  action: z27.literal("proposals-respond"),
-  proposalId: z27.string().max(200),
-  verdict: z27.enum(["approve", "reject"]),
-  reason: z27.string().max(2e3).optional()
+var workspaceProposalsRespondVariant = z29.object({
+  action: z29.literal("proposals-respond"),
+  proposalId: z29.string().max(200),
+  verdict: z29.enum(["approve", "reject"]),
+  reason: z29.string().max(2e3).optional()
 });
-var workspaceProposalsCountVariant = z27.object({ action: z27.literal("proposals-count") });
-var workspaceActionUnion = z27.discriminatedUnion("action", [
+var workspaceProposalsCountVariant = z29.object({ action: z29.literal("proposals-count") });
+var workspaceActionUnion = z29.discriminatedUnion("action", [
   workspaceCheckVariant,
   workspaceWhoamiVariant,
   workspaceStatusVariant,
@@ -14564,7 +15019,7 @@ function registerWorkspaceTools(server) {
 }
 
 // src/tools/feedback.ts
-import { z as z28 } from "zod/v3";
+import { z as z30 } from "zod/v3";
 
 // src/lib/productFeedbackConstants.ts
 var PRODUCT_FEEDBACK_CATEGORIES = ["bug", "friction", "idea", "praise", "other"];
@@ -14575,9 +15030,9 @@ var VENDOR_SETTABLE_STATUSES = PRODUCT_FEEDBACK_STATUSES.filter(
 
 // src/tools/feedback.ts
 var actions = ["submit", "list", "queue", "note", "group", "status"];
-var category = z28.enum(PRODUCT_FEEDBACK_CATEGORIES);
-var status = z28.enum(PRODUCT_FEEDBACK_STATUSES);
-var vendorStatus = z28.enum(VENDOR_SETTABLE_STATUSES);
+var category = z30.enum(PRODUCT_FEEDBACK_CATEGORIES);
+var status = z30.enum(PRODUCT_FEEDBACK_STATUSES);
+var vendorStatus = z30.enum(VENDOR_SETTABLE_STATUSES);
 var GATEWAY_MAX_STRING_BYTES = 10240;
 var utf8Bytes = (value) => new TextEncoder().encode(value).length;
 var fitsGatewayBytes = (value) => utf8Bytes(value) <= GATEWAY_MAX_STRING_BYTES;
@@ -14586,32 +15041,32 @@ var byteLimitMessage = (field) => ({
 });
 var MESSAGE_DISPLAY_LIMIT = 1e3;
 var FULL_MESSAGE_MAX_LIMIT = 5;
-var feedbackSchema = z28.object({
-  action: z28.enum(actions).describe("submit requires message; list returns your own workspace's feedback (all statuses); queue is the vendor triage queue (system admins only) and accepts filters; note requires feedbackId+note; group requires feedbackIds+groupId (null clears); status requires feedbackId+status."),
-  message: z28.string().max(1e4).optional().describe("Required for submit: the product feedback text (max 10,000 chars and 10,240 UTF-8 bytes)."),
+var feedbackSchema = z30.object({
+  action: z30.enum(actions).describe("submit requires message; list returns your own workspace's feedback (all statuses); queue is the vendor triage queue (system admins only) and accepts filters; note requires feedbackId+note; group requires feedbackIds+groupId (null clears); status requires feedbackId+status."),
+  message: z30.string().max(1e4).optional().describe("Required for submit: the product feedback text (max 10,000 chars and 10,240 UTF-8 bytes)."),
   category: category.optional().describe("Submit/queue category; submit defaults to other."),
-  command: z28.string().max(1e3).optional().describe("Optional submit command context; argument values are scrubbed server-side."),
-  route: z28.string().max(500).optional().describe("Optional submit route context."),
-  client: z28.string().max(100).optional().describe("Optional submit client label."),
-  feedbackId: z28.string().max(200).optional().describe("Required for note/status: target feedback ID."),
-  feedbackIds: z28.array(z28.string().max(200)).max(100).optional().describe("Required for group: 1\u2013100 target feedback IDs."),
-  note: z28.string().max(4e3).optional().describe("Required for note: replacement triage note (max 10,240 UTF-8 bytes)."),
+  command: z30.string().max(1e3).optional().describe("Optional submit command context; argument values are scrubbed server-side."),
+  route: z30.string().max(500).optional().describe("Optional submit route context."),
+  client: z30.string().max(100).optional().describe("Optional submit client label."),
+  feedbackId: z30.string().max(200).optional().describe("Required for note/status: target feedback ID."),
+  feedbackIds: z30.array(z30.string().max(200)).max(100).optional().describe("Required for group: 1\u2013100 target feedback IDs."),
+  note: z30.string().max(4e3).optional().describe("Required for note: replacement triage note (max 10,240 UTF-8 bytes)."),
   status: status.optional().describe("list/queue filter (any status, including 'screening'); the status action's required target value excludes 'screening' (system-only)."),
-  groupId: z28.string().min(1).max(200).nullable().optional().describe("Group filter, or required group destination; null explicitly clears grouping."),
-  workspaceId: z28.string().max(200).optional().describe("Queue-only filter (vendor cross-workspace triage); omitted means all workspaces. Has no effect on list \u2014 your own workspace is always injected server-side."),
-  since: z28.number().optional().describe("Queue-only lower createdAt window bound (inclusive) in epoch milliseconds."),
-  before: z28.number().optional().describe("Queue-only upper createdAt window bound (exclusive) in epoch milliseconds. A time-window FILTER, not the pager \u2014 use cursor to page."),
-  limit: z28.number().int().min(1).max(100).optional().describe("list/queue row limit, default 50, maximum 100."),
-  cursor: z28.string().max(2e3).optional().describe("Opaque pagination cursor from a previous list/queue response (continueCursor); omit for the first page."),
-  full: z28.boolean().optional().describe(`list/queue only: return untruncated messages; allowed only when limit <= ${FULL_MESSAGE_MAX_LIMIT}.`)
+  groupId: z30.string().min(1).max(200).nullable().optional().describe("Group filter, or required group destination; null explicitly clears grouping."),
+  workspaceId: z30.string().max(200).optional().describe("Queue-only filter (vendor cross-workspace triage); omitted means all workspaces. Has no effect on list \u2014 your own workspace is always injected server-side."),
+  since: z30.number().optional().describe("Queue-only lower createdAt window bound (inclusive) in epoch milliseconds."),
+  before: z30.number().optional().describe("Queue-only upper createdAt window bound (exclusive) in epoch milliseconds. A time-window FILTER, not the pager \u2014 use cursor to page."),
+  limit: z30.number().int().min(1).max(100).optional().describe("list/queue row limit, default 50, maximum 100."),
+  cursor: z30.string().max(2e3).optional().describe("Opaque pagination cursor from a previous list/queue response (continueCursor); omit for the first page."),
+  full: z30.boolean().optional().describe(`list/queue only: return untruncated messages; allowed only when limit <= ${FULL_MESSAGE_MAX_LIMIT}.`)
 });
-var union = z28.discriminatedUnion("action", [
-  z28.object({ action: z28.literal("submit"), message: z28.string().min(1).max(1e4).refine(fitsGatewayBytes, byteLimitMessage("message")), category: category.optional(), command: z28.string().max(1e3).optional(), route: z28.string().max(500).optional(), client: z28.string().max(100).optional() }),
-  z28.object({ action: z28.literal("list"), status: status.optional(), limit: z28.number().int().min(1).max(100).optional(), cursor: z28.string().max(2e3).optional(), full: z28.boolean().optional() }),
-  z28.object({ action: z28.literal("queue"), status: status.optional(), category: category.optional(), groupId: z28.string().min(1).max(200).optional(), workspaceId: z28.string().max(200).optional(), since: z28.number().optional(), before: z28.number().optional(), limit: z28.number().int().min(1).max(100).optional(), cursor: z28.string().max(2e3).optional(), full: z28.boolean().optional() }),
-  z28.object({ action: z28.literal("note"), feedbackId: z28.string().min(1).max(200), note: z28.string().max(4e3).refine(fitsGatewayBytes, byteLimitMessage("note")) }),
-  z28.object({ action: z28.literal("group"), feedbackIds: z28.array(z28.string().min(1).max(200)).min(1).max(100), groupId: z28.string().min(1).max(200).nullable() }),
-  z28.object({ action: z28.literal("status"), feedbackId: z28.string().min(1).max(200), status: vendorStatus })
+var union = z30.discriminatedUnion("action", [
+  z30.object({ action: z30.literal("submit"), message: z30.string().min(1).max(1e4).refine(fitsGatewayBytes, byteLimitMessage("message")), category: category.optional(), command: z30.string().max(1e3).optional(), route: z30.string().max(500).optional(), client: z30.string().max(100).optional() }),
+  z30.object({ action: z30.literal("list"), status: status.optional(), limit: z30.number().int().min(1).max(100).optional(), cursor: z30.string().max(2e3).optional(), full: z30.boolean().optional() }),
+  z30.object({ action: z30.literal("queue"), status: status.optional(), category: category.optional(), groupId: z30.string().min(1).max(200).optional(), workspaceId: z30.string().max(200).optional(), since: z30.number().optional(), before: z30.number().optional(), limit: z30.number().int().min(1).max(100).optional(), cursor: z30.string().max(2e3).optional(), full: z30.boolean().optional() }),
+  z30.object({ action: z30.literal("note"), feedbackId: z30.string().min(1).max(200), note: z30.string().max(4e3).refine(fitsGatewayBytes, byteLimitMessage("note")) }),
+  z30.object({ action: z30.literal("group"), feedbackIds: z30.array(z30.string().min(1).max(200)).min(1).max(100), groupId: z30.string().min(1).max(200).nullable() }),
+  z30.object({ action: z30.literal("status"), feedbackId: z30.string().min(1).max(200), status: vendorStatus })
 ]);
 var specs = {
   submit: { params: ["message", "category", "command", "route", "client"], description: "message is required; category defaults to other." },
@@ -14738,34 +15193,34 @@ function registerFeedbackTool(server) {
 }
 
 // src/tools/shape.ts
-import { z as z29 } from "zod/v3";
+import { z as z31 } from "zod/v3";
 var SHAPE_ACTIONS = ["list", "show", "agree", "dismiss"];
 var LIST_DISPOSITIONS = ["pending", "agreed", "dismissed", "expired"];
 var LIST_OUTCOMES = ["not_candidate", "atomic", "compound", "unavailable"];
-var shapeSchema = z29.object({
-  action: z29.enum(SHAPE_ACTIONS).describe(
+var shapeSchema = z31.object({
+  action: z31.enum(SHAPE_ACTIONS).describe(
     "'list': list shape advisories for this workspace, latest per subject. 'show': show one shape advisory by id. 'agree': agree with a compound advisory's split verdict. 'dismiss': dismiss a compound advisory's split verdict."
   ),
-  disposition: z29.enum(LIST_DISPOSITIONS).optional().describe(
+  disposition: z31.enum(LIST_DISPOSITIONS).optional().describe(
     "For 'list': filter by disposition. Omitting both disposition and outcome defaults to the actionable set (disposition:pending, outcome:compound)."
   ),
-  outcome: z29.enum(LIST_OUTCOMES).optional().describe(
+  outcome: z31.enum(LIST_OUTCOMES).optional().describe(
     "For 'list': filter by outcome. Omitting both disposition and outcome defaults to the actionable set (disposition:pending, outcome:compound)."
   ),
-  limit: z29.number().min(1).max(200).optional().describe("For 'list': max rows (default 50, max 200)."),
-  rowId: z29.string().max(200).optional().describe("For 'show'/'agree'/'dismiss': the advisory row id."),
-  reason: z29.string().max(1e3).optional().describe("For 'agree'/'dismiss': optional reason (capped at 1000 chars).")
+  limit: z31.number().min(1).max(200).optional().describe("For 'list': max rows (default 50, max 200)."),
+  rowId: z31.string().max(200).optional().describe("For 'show'/'agree'/'dismiss': the advisory row id."),
+  reason: z31.string().max(1e3).optional().describe("For 'agree'/'dismiss': optional reason (capped at 1000 chars).")
 });
-var shapeListVariant = z29.object({
-  action: z29.literal("list"),
-  disposition: z29.enum(LIST_DISPOSITIONS).optional(),
-  outcome: z29.enum(LIST_OUTCOMES).optional(),
-  limit: z29.number().min(1).max(200).optional()
+var shapeListVariant = z31.object({
+  action: z31.literal("list"),
+  disposition: z31.enum(LIST_DISPOSITIONS).optional(),
+  outcome: z31.enum(LIST_OUTCOMES).optional(),
+  limit: z31.number().min(1).max(200).optional()
 });
-var shapeShowVariant = z29.object({ action: z29.literal("show"), rowId: z29.string().max(200) });
-var shapeAgreeVariant = z29.object({ action: z29.literal("agree"), rowId: z29.string().max(200), reason: z29.string().max(1e3).optional() });
-var shapeDismissVariant = z29.object({ action: z29.literal("dismiss"), rowId: z29.string().max(200), reason: z29.string().max(1e3).optional() });
-var shapeActionUnion = z29.discriminatedUnion("action", [
+var shapeShowVariant = z31.object({ action: z31.literal("show"), rowId: z31.string().max(200) });
+var shapeAgreeVariant = z31.object({ action: z31.literal("agree"), rowId: z31.string().max(200), reason: z31.string().max(1e3).optional() });
+var shapeDismissVariant = z31.object({ action: z31.literal("dismiss"), rowId: z31.string().max(200), reason: z31.string().max(1e3).optional() });
+var shapeActionUnion = z31.discriminatedUnion("action", [
   shapeListVariant,
   shapeShowVariant,
   shapeAgreeVariant,
@@ -15432,12 +15887,12 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 }
 
 // src/prompts/index.ts
-import { z as z30 } from "zod/v3";
+import { z as z32 } from "zod/v3";
 function registerPrompts(server) {
   server.prompt(
     "review-against-rules",
     "Review code or a design decision against all business rules for a given domain. Fetches the rules and asks you to do a structured compliance review.",
-    { domain: z30.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z32.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
     async ({ domain }) => {
       const entries = await kernelQuery("chain.listEntries", { collectionSlug: "business-rules" });
       const rules = entries.filter((e) => e.data?.domain === domain);
@@ -15490,7 +15945,7 @@ Provide a structured review with a compliance status for each rule (COMPLIANT /
   server.prompt(
     "name-check",
     "Check variable names, field names, or API names against the glossary for terminology alignment. Flags drift from canonical terms.",
-    { names: z30.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z32.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
     async ({ names }) => {
       const terms = await kernelQuery("chain.listEntries", { collectionSlug: "glossary" });
       const glossaryContext = terms.map(
@@ -15526,7 +15981,7 @@ Format as a table: Name | Status | Canonical Form | Action Needed`
   server.prompt(
     "draft-decision-record",
     "Draft a structured decision record from a description of what was decided. Includes context from recent decisions and relevant rules.",
-    { context: z30.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z32.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
     async ({ context }) => {
       const recentDecisions = await kernelQuery("chain.listEntries", { collectionSlug: "decisions" });
       const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
@@ -15564,8 +16019,8 @@ After drafting, I can log it using the capture tool with collection "decisions".
     "draft-rule-from-context",
     "Draft a new business rule from an observation or discovery made while coding. Fetches existing rules for the domain to ensure consistency.",
     {
-      observation: z30.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
-      domain: z30.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z32.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z32.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
     },
     async ({ observation, domain }) => {
       const allRules = await kernelQuery("chain.listEntries", { collectionSlug: "business-rules" });
@@ -15841,4 +16296,4 @@ export {
   createProductBrainServer,
   initFeatureFlags
 };
-//# sourceMappingURL=chunk-252CQV5P.js.map
+//# sourceMappingURL=chunk-KTRECBYJ.js.map