@productbrain/mcp 0.0.1-beta.3503 → 0.0.1-beta.3516

package/dist/{chunk-W66ODVGP.js → chunk-PEAWB3EE.js}

@@ -2,10 +2,12 @@ import {
   KernelCallError,
   cacheScope,
   closeAgentSession,
+  formatGatewaySeamSummary,
   getAgentSessionId,
   getApiKeyScope,
   getAuditLog,
   getConversationId,
+  getMergedGatewaySeamCounters,
   getRequestApiKey,
   getWorkspaceContext,
   getWorkspaceId,
@@ -40,13 +42,13 @@ import {
   trackSessionCaptureRate,
   trackWriteBackHintServed,
   trackZeroCaptureAuditFired
-} from "./chunk-U7YKAA66.js";
+} from "./chunk-VCTFH2U7.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/tools/entries.ts
-import { z as z9 } from "zod/v3";
+import { z as z10 } from "zod/v3";
 
 // src/envelope.ts
 import { z } from "zod/v3";
@@ -178,6 +180,14 @@ function classifyError(err) {
       return { code, message, recovery, availableActions: [action] };
     }
   }
+  if (err?.name === "GatewayTimeoutError") {
+    const mayHaveLanded = err.mayHaveLanded === true;
+    return {
+      code: "GATEWAY_TIMEOUT",
+      message,
+      recovery: mayHaveLanded ? "The server was reachable and may have completed this write \u2014 verify before retrying, since a blind retry can duplicate it." : "The server was reachable but did not answer in time. Nothing was written \u2014 safe to retry."
+    };
+  }
   if (/network error|fetch failed|ECONNREFUSED|ETIMEDOUT/i.test(message)) {
     return { code: "BACKEND_UNAVAILABLE", message, recovery: "Retry in a few seconds." };
   }
@@ -540,10 +550,96 @@ async function dispatchDiscriminated(toolName, union2, flatData, actionSpecs, ha
 }
 
 // src/tools/knowledge.ts
-import { z as z6 } from "zod/v3";
+import { z as z7 } from "zod/v3";
 
 // src/tools/smart-capture.ts
-import { z as z4 } from "zod/v3";
+import { z as z5 } from "zod/v3";
+
+// src/lib/captureTimeoutOutcome.ts
+function isGatewayTimeout(error) {
+  return error?.name === "GatewayTimeoutError";
+}
+function buildCaptureOutcomeUnknownResult(error, name, msg) {
+  if (!error.mayHaveLanded) return buildDryRunTimeoutResult(error, msg);
+  const recovery = `Search for "${name}" before retrying \u2014 a retry will duplicate it if the write landed. If found, read back its commit status and coaching output before assuming either is missing.`;
+  return {
+    content: [{
+      type: "text",
+      text: `# Capture Outcome Unknown \u2014 Not Failed
+
+${msg}
+
+**What is known:** the request reached the server and this client gave up waiting after ${error.elapsedMs}ms. The entry **may or may not** have been written.
+
+**What definitely did NOT run:** relation linking \u2014 a separate mutation issued after the create returns, so it is never reached when create itself times out.
+
+**What may also have run \u2014 outcome unknown, same reason as the entry itself:** auto-commit and quality coaching. Both execute INSIDE the create call, before it returns, so if the server finished after this client stopped waiting, they ran too. Do not assume either is absent \u2014 read the entry back to find out.
+
+**Do this next:** ${recovery}`
+    }],
+    structuredContent: failure(
+      "CAPTURE_OUTCOME_UNKNOWN",
+      msg,
+      recovery,
+      [{ tool: "entries", description: "Search for the entry before retrying", parameters: { action: "search", query: name } }],
+      {
+        // Structured so a caller can branch on this without parsing prose — the
+        // reconciliation signal TEN-1126 says the capture path never had.
+        partialSuccess: true,
+        mayHaveLanded: error.mayHaveLanded,
+        budgetMs: error.budgetMs,
+        elapsedMs: error.elapsedMs,
+        completedBeforeTimeout: [],
+        // WP-575 review (P1): genuinely definite — relation linking is a separate mutation
+        // never reached when create throws. See the doc comment above for why `commit` and
+        // `coaching` were removed from this list.
+        didNotRun: ["relations"],
+        // WP-575 review (P1): distinct from `didNotRun` on purpose — these ran INSIDE the
+        // same server call as the create, so their outcome is exactly as unknown as the
+        // entry's. A caller must read the entry back, never assume either ran or didn't.
+        mayHaveRun: ["commit", "coaching"]
+      }
+    )
+  };
+}
+function buildDryRunTimeoutResult(error, msg) {
+  const recovery = "Re-run the preview \u2014 nothing was written, so there is nothing to search for and nothing to duplicate.";
+  return {
+    content: [{
+      type: "text",
+      text: `# Preview Outcome Unknown \u2014 Nothing Was Written
+
+${msg}
+
+**What is known:** the request reached the server and this client gave up waiting after ${error.elapsedMs}ms. This was a **preview**, and the server returns its validation result before performing any write \u2014 so no entry, auto-commit, quality coaching, or relation linking happened.
+
+**What is unknown:** the validation verdict this preview was asked for.
+
+**Do this next:** ${recovery}`
+    }],
+    structuredContent: failure(
+      "CAPTURE_OUTCOME_UNKNOWN",
+      msg,
+      recovery,
+      [],
+      {
+        // No partial success to reconcile: a dry run has no server-side state to converge on.
+        partialSuccess: false,
+        mayHaveLanded: false,
+        budgetMs: error.budgetMs,
+        elapsedMs: error.elapsedMs,
+        completedBeforeTimeout: [],
+        didNotRun: ["entry", "relations", "commit", "coaching"],
+        mayHaveRun: []
+      }
+    )
+  };
+}
+function describeBatchEntryError(error, entryName) {
+  const msg = error instanceof Error ? error.message : String(error);
+  if (!isGatewayTimeout(error)) return msg;
+  return error.mayHaveLanded ? `${msg} Outcome unknown for this entry \u2014 search for "${entryName}" before re-running the batch, or it may be captured twice.` : `${msg} This was a preview, so nothing was written for this entry \u2014 safe to re-run the batch.`;
+}
 
 // src/lib/scopedCache.ts
 var ScopedCache = class {
@@ -837,110 +933,167 @@ function tokenizeText(input) {
 }
 
 // src/lib/batchCaptureOutput.ts
+import { z as z3 } from "zod/v3";
+
+// src/lib/batchTimeoutCohort.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(),
+var unknownOutcomeEntrySchema = z2.object({
+  index: z2.number(),
+  collection: z2.string(),
+  name: z2.string(),
+  error: z2.string(),
+  mayHaveLanded: z2.boolean(),
+  budgetMs: z2.number(),
+  elapsedMs: z2.number()
+});
+function deriveTimeoutOutcome(error) {
+  return isGatewayTimeout(error) ? { mayHaveLanded: error.mayHaveLanded, budgetMs: error.budgetMs, elapsedMs: error.elapsedMs } : void 0;
+}
+function describeBatchEntryOutcome(error, entryName) {
+  return { error: describeBatchEntryError(error, entryName), timeoutOutcome: deriveTimeoutOutcome(error) };
+}
+function splitBatchNotOk(notOk) {
+  return {
+    failed: notOk.filter((r) => !r.timeoutOutcome),
+    unknownOutcome: notOk.filter((r) => r.timeoutOutcome).map((r) => ({
+      index: r.entryIdx,
+      collection: r.collection,
+      name: r.name,
+      error: r.error ?? "unknown error",
+      mayHaveLanded: r.timeoutOutcome.mayHaveLanded,
+      budgetMs: r.timeoutOutcome.budgetMs,
+      elapsedMs: r.timeoutOutcome.elapsedMs
+    }))
+  };
+}
+function unknownOutcomeSummaryNote(entries) {
+  return entries.length > 0 ? `, ${entries.length} outcome unknown` : "";
+}
+function renderOutcomeUnknownSection(entries) {
+  if (entries.length === 0) return [];
+  const anyMayHaveLanded = entries.some((e) => e.mayHaveLanded);
+  return [
+    "",
+    "## Outcome Unknown \u2014 Not Failed",
+    ...entries.map((e) => `- ${e.name} [${e.collection}]: _${e.error}_`),
+    "",
+    anyMayHaveLanded ? "_Do NOT retry these individually \u2014 search for each name first (see `unknownOutcomeEntries` in the structured response); a retry may duplicate an entry that already landed._" : "_Nothing was written for these \u2014 the preview returns before any write, so re-running is safe. Only the validation verdict is missing._"
+  ];
+}
+
+// src/lib/batchCaptureOutput.ts
+var batchCaptureRealOutputSchema = z3.object({
+  captured: z3.array(z3.object({
+    entryId: z3.string(),
+    collection: z3.string(),
+    name: z3.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()
+    status: z3.enum(["draft", "committed", "proposed", "draft_on_failure"]),
+    classifiedBy: z3.enum(["llm", "heuristic", "explicit"]).optional(),
+    confidence: z3.number().optional(),
+    confidenceTier: z3.enum(["high", "medium", "low"]).optional(),
+    warnings: z3.array(z3.string()).optional(),
+    normalization: z3.object({
+      remapped: z3.record(z3.string()).optional(),
+      rejected: z3.array(z3.string()).optional()
     }).optional(),
     // TEN-2365: capture-time authority-domain proposal slug (PENDING ratification), when filed.
-    domain: z2.string().optional(),
+    domain: z3.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(),
+    coherencyRefusal: z3.record(z3.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()
+    contradictionAdvisory: z3.record(z3.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()
+  total: z3.number(),
+  failed: z3.number(),
+  committed: z3.number(),
+  proposed: z3.number(),
+  drafts: z3.number(),
+  classified: z3.number().optional(),
+  autoCommitApplied: z3.boolean(),
+  skippedLowConfidence: z3.array(z3.object({
+    index: z3.number(),
+    name: z3.string(),
+    suggestedCollection: z3.string().optional(),
+    confidence: z3.number().optional(),
+    alternatives: z3.array(z3.object({
+      collection: z3.string(),
+      confidence: z3.number()
     })).optional()
   })).optional(),
-  failedEntries: z2.array(z2.object({
-    index: z2.number(),
-    collection: z2.string(),
-    name: z2.string(),
-    error: z2.string()
-  })).optional()
+  failedEntries: z3.array(z3.object({
+    index: z3.number(),
+    collection: z3.string(),
+    name: z3.string(),
+    error: z3.string()
+  })).optional(),
+  // WP-575 review round (P1, TEN-1126): a DISTINCT cohort from `failedEntries` — additive,
+  // never removes or retypes an existing field (repo's schema rule). See
+  // lib/batchTimeoutCohort.ts's doc comment for why this must stay separate.
+  unknownOutcomeEntries: z3.array(unknownOutcomeEntrySchema).optional()
 });
-var batchCapturePreviewOutputSchema = z2.object({
-  outcome: z2.literal("preview"),
-  wouldCapture: z2.array(z2.object({
+var batchCapturePreviewOutputSchema = z3.object({
+  outcome: z3.literal("preview"),
+  wouldCapture: z3.array(z3.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()
+    entryId: z3.string().optional(),
+    entryIdAssignedAtCapture: z3.literal(true).optional(),
+    collection: z3.string(),
+    name: z3.string(),
+    classifiedBy: z3.string().optional(),
+    confidence: z3.number().optional(),
+    warnings: z3.array(z3.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()
+  wouldBlock: z3.array(z3.object({
+    entryId: z3.string().optional(),
+    entryIdAssignedAtCapture: z3.literal(true).optional(),
+    collection: z3.string(),
+    name: z3.string(),
+    blockingReason: z3.string().optional(),
+    warnings: z3.array(z3.string()).optional()
+  })).optional(),
+  requested: z3.number(),
+  total: z3.number(),
+  failed: z3.number(),
+  skippedLowConfidence: z3.array(z3.object({
+    index: z3.number(),
+    name: z3.string(),
+    suggestedCollection: z3.string().optional(),
+    confidence: z3.number().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()
+  failedEntries: z3.array(z3.object({
+    index: z3.number(),
+    collection: z3.string(),
+    name: z3.string(),
+    error: z3.string()
   })).optional(),
-  failedEntries: z2.array(z2.object({
-    index: z2.number(),
-    collection: z2.string(),
-    name: z2.string(),
-    error: z2.string()
-  })).optional()
+  // WP-575 review round (P1, TEN-1126): sibling of the same field on
+  // batchCaptureRealOutputSchema — preview batches reach the SAME unconditional
+  // `chain.createEntry` catch a real batch does, so the discriminator exists here too.
+  unknownOutcomeEntries: z3.array(unknownOutcomeEntrySchema).optional()
 });
-var batchCaptureOutputSchema = z2.union([
+var batchCaptureOutputSchema = z3.union([
   batchCaptureRealOutputSchema,
   batchCapturePreviewOutputSchema
 ]);
-function buildBatchPreviewSummary({ wouldCapture, wouldBlock = [], failed, skipped, requested }) {
+function buildBatchPreviewSummary({ wouldCapture, wouldBlock = [], failed, unknownOutcome = [], 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 unknownNote = unknownOutcomeSummaryNote(unknownOutcome);
   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.`;
+  return `Preview: would capture ${wouldCapture.length} of ${requested} ${noun}${blockedNote}${failedNote}${unknownNote}${skippedNote} \u2014 no DB writes.`;
 }
 function buildBatchEntryFailure(args) {
   return {
@@ -955,12 +1108,14 @@ function buildBatchEntryFailure(args) {
     classifiedBy: args.classifiedBy,
     confidence: args.confidence,
     confidenceTier: args.confidenceTier,
-    error: args.error
+    error: args.error,
+    ...args.timeoutOutcome ? { timeoutOutcome: args.timeoutOutcome } : {}
   };
 }
 function buildBatchPreviewFromResults(created, failed, skipped, requested, originalItems, originalAutoCommit) {
   const wouldCaptureEntries = created.filter((r) => !r.wouldBlock);
   const wouldBlockEntries = created.filter((r) => r.wouldBlock);
+  const { failed: genuinelyFailed, unknownOutcome: timedOut } = splitBatchNotOk(failed);
   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
@@ -980,7 +1135,9 @@ function buildBatchPreviewFromResults(created, failed, skipped, requested, origi
       ...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" })),
+    failed: genuinelyFailed.map((r) => ({ index: r.entryIdx, collection: r.collection, name: r.name, error: r.error ?? "unknown error" })),
+    unknownOutcome: timedOut,
+    // WP-575 review (P1, TEN-1126) — see lib/batchTimeoutCohort.ts.
     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
@@ -993,7 +1150,7 @@ function buildBatchPreviewFromResults(created, failed, skipped, requested, origi
   });
 }
 function buildBatchPreviewResult(input) {
-  const { wouldCapture, wouldBlock = [], failed, skipped, requested, originalItems, originalAutoCommit } = input;
+  const { wouldCapture, wouldBlock = [], failed, unknownOutcome = [], skipped, requested, originalItems, originalAutoCommit } = input;
   const summary = buildBatchPreviewSummary(input);
   const lines = [`# Batch Preview \u2014 No Entries Created`, summary, ""];
   if (wouldCapture.length > 0) {
@@ -1032,6 +1189,7 @@ function buildBatchPreviewResult(input) {
     }
     lines.push("");
   }
+  lines.push(...renderOutcomeUnknownSection(unknownOutcome));
   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",
@@ -1058,7 +1216,10 @@ function buildBatchPreviewResult(input) {
           total: wouldCapture.length,
           failed: failed.length,
           ...skipped.length > 0 ? { skippedLowConfidence: skipped } : {},
-          ...failed.length > 0 ? { failedEntries: failed } : {}
+          ...failed.length > 0 ? { failedEntries: failed } : {},
+          // WP-575 review round (P1, TEN-1126): structured sibling of `failedEntries` — see
+          // `UnknownOutcomeEntry`'s doc comment for why these are never merged into it.
+          ...unknownOutcome.length > 0 ? { unknownOutcomeEntries: unknownOutcome } : {}
         },
         next
       )
@@ -1295,42 +1456,42 @@ function formatRubricVerdictSection(verdict) {
 }
 
 // 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()
+import { z as z4 } from "zod/v3";
+var groundingRelatedEntrySchema = z4.object({
+  entryId: z4.string(),
+  name: z4.string(),
+  collectionSlug: z4.string(),
+  overlapRatio: z4.number(),
+  recommendedRelationType: z4.string(),
+  reasoning: z4.string()
 });
-var groundingDuplicateEntrySchema = z3.object({
-  entryId: z3.string(),
-  name: z3.string(),
-  collectionSlug: z3.string(),
-  matchType: z3.enum(["related", "possible_duplicate"]),
-  overlapRatio: z3.number()
+var groundingDuplicateEntrySchema = z4.object({
+  entryId: z4.string(),
+  name: z4.string(),
+  collectionSlug: z4.string(),
+  matchType: z4.enum(["related", "possible_duplicate"]),
+  overlapRatio: z4.number()
 });
-var groundingGovernanceEntrySchema = z3.object({
-  entryId: z3.string(),
-  name: z3.string(),
-  collectionSlug: z3.string()
+var groundingGovernanceEntrySchema = z4.object({
+  entryId: z4.string(),
+  name: z4.string(),
+  collectionSlug: z4.string()
 });
-var groundingReportSchema = z3.object({
-  related: z3.array(groundingRelatedEntrySchema),
-  duplicates: z3.array(groundingDuplicateEntrySchema),
-  governance: z3.array(groundingGovernanceEntrySchema)
+var groundingReportSchema = z4.object({
+  related: z4.array(groundingRelatedEntrySchema),
+  duplicates: z4.array(groundingDuplicateEntrySchema),
+  governance: z4.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"]),
+var taskAlignmentSchema = z4.record(z4.unknown());
+var captureSinglePreviewOutputSchema = z4.object({
+  entryId: z4.string(),
+  name: z4.string(),
+  collection: z4.string(),
+  outcome: z4.enum(["preview", "blocked"]),
   // Present only when `outcome: "blocked"` AND the server supplied a reason.
-  blockingReason: z3.string().optional(),
+  blockingReason: z4.string().optional(),
   // Always present — `result.warnings ?? []`, never omitted.
-  warnings: z3.array(z3.string()),
+  warnings: z4.array(z4.string()),
   groundingReport: groundingReportSchema,
   // TEN-2458: only present when the kernel computed a librarian verdict for this preview.
   taskAlignment: taskAlignmentSchema.optional()
@@ -1522,81 +1683,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 = 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+')"),
+var entryIdSchema = z5.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 = z5.object({
+  collection: z5.string().optional().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional \u2014 classifier auto-routes when omitted."),
+  name: z5.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
+  description: z5.string().describe("Full context \u2014 what's happening, why it matters, what you observed"),
+  context: z5.string().optional().describe("Optional additional context (e.g. 'Observed during context gather calls taking 700ms+')"),
   entryId: entryIdSchema,
-  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')")
+  canonicalKey: z5.string().optional().describe("Semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted."),
+  data: z5.record(z5.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: z5.array(z5.object({
+    to: z5.string().describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
+    type: z5.string().describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
   })).optional().describe("Relations to create after capture. Skips auto-link discovery when provided."),
-  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."),
+  autoCommit: z5.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: z5.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: z5.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: z4.boolean().optional().describe("If true, validates the capture without writing. Returns what would happen. Default false."),
+  preview: z5.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: 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."),
+  suggestOnly: z5.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: 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."),
+  format: z5.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: 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).")
+  ownerTeamEntryId: z5.string().max(200).optional().describe("Owning team entry ID/ref (rung 2)."),
+  ownerRoleEntryId: z5.string().max(200).optional().describe("Owning role entry ID/ref (rung 2).")
 });
-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 batchCaptureRelationSchema = z5.object({
+  to: z5.string().max(200).describe("Target entry ID already on the Chain, e.g. '<PREFIX>-<n>'."),
+  type: z5.string().max(200).describe("Relation type, e.g. 'related_to', 'informed_by', 'governs'.")
 });
-var batchCaptureSchema = z4.object({
-  entries: z4.array(z4.object({
+var batchCaptureSchema = z5.object({
+  entries: z5.array(z5.object({
     // FEAT-160
-    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"),
+    collection: z5.string().max(200).optional().describe("Collection slug. Optional \u2014 auto-classified via LLM when omitted."),
+    name: z5.string().max(500).describe("Display name"),
+    description: z5.string().max(2e4).describe("Full context / definition"),
     entryId: entryIdSchema,
-    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."),
+    data: z5.record(z5.unknown()).optional().describe("Explicit field values (e.g. urgency, status, assignee). Merged with inferred values; user-provided wins."),
+    canonicalKey: z5.string().max(200).optional().describe("Semantic type (e.g. 'decision', 'tension', 'work_package'). Enables work-package redirect in createEntry when collection is 'chains'."),
+    sourceRef: z5.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: z5.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: 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."),
+    relations: z5.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: 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).")
+    ownerTeamEntryId: z5.string().max(200).optional().describe("Owning team entry ID/ref (rung 2)."),
+    ownerRoleEntryId: z5.string().max(200).optional().describe("Owning role entry ID/ref (rung 2).")
   })).min(1).max(50).describe("Array of entries to capture"),
-  autoCommit: z4.boolean().optional().describe(
+  autoCommit: z5.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: z4.boolean().optional().describe("If true, validates all captures without writing. Returns what would happen. Default false.")
+  preview: z5.boolean().optional().describe("If true, validates all captures without writing. Returns what would happen. Default false.")
 });
-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(),
+var captureClassifierSchema = z5.object({
+  enabled: z5.boolean(),
+  autoRouted: z5.boolean(),
+  agrees: z5.boolean(),
+  abstained: z5.boolean(),
+  topConfidence: z5.number(),
+  confidence: z5.number(),
+  reasons: z5.array(z5.string()),
+  candidates: z5.array(
+    z5.object({
+      collection: z5.string(),
+      signalScore: z5.number().optional(),
+      confidence: z5.number(),
       /** WP-316 S2: required-field cost — how many fields the agent must supply for this collection. */
-      requiredFieldCount: z4.number().optional()
+      requiredFieldCount: z5.number().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()
+  agentProvidedCollection: z5.string().optional(),
+  overrideCommand: z5.string().optional(),
+  classifiedBy: z5.enum(["llm", "heuristic", "explicit"]).optional(),
+  confidenceTier: z5.enum(["high", "medium", "low"]).optional(),
+  reasoning: z5.string().optional()
 });
 function trackClassifierTelemetry(params) {
   const telemetry = {
@@ -1824,51 +1985,51 @@ async function resolveCaptureCollection(params) {
     classifierMeta
   };
 }
-var captureSuccessOutputSchema = z4.object({
-  entryId: z4.string(),
-  collection: z4.string(),
-  name: z4.string(),
+var captureSuccessOutputSchema = z5.object({
+  entryId: z5.string(),
+  collection: z5.string(),
+  name: z5.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: z4.enum(["draft", "committed", "proposed", "draft_on_failure"]),
+  status: z5.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: z4.record(z4.unknown()).optional(),
+  qualityVerdict: z5.record(z5.unknown()).optional(),
   classifier: captureClassifierSchema.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()
+  studioUrl: z5.string().optional(),
+  warnings: z5.array(z5.string()).optional(),
+  normalization: z5.object({
+    remapped: z5.record(z5.string()).optional(),
+    rejected: z5.array(z5.string()).optional()
   }).optional(),
-  expectedFields: z4.array(z4.object({
-    key: z4.string(),
-    type: z4.string(),
-    required: z4.boolean().optional()
+  expectedFields: z5.array(z5.object({
+    key: z5.string(),
+    type: z5.string(),
+    required: z5.boolean().optional()
   })).optional(),
   // TEN-2365: capture-time authority-domain proposal (PENDING ratification), when one was filed.
-  authorityDomain: z4.object({
-    slug: z4.string(),
-    status: z4.literal("proposal-pending")
+  authorityDomain: z5.object({
+    slug: z5.string(),
+    status: z5.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: z4.record(z4.unknown()).optional(),
+  coherencyRefusal: z5.record(z5.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: z4.record(z4.unknown()).optional()
+  contradictionAdvisory: z5.record(z5.unknown()).optional()
 }).strict();
-var captureClassifierOnlyOutputSchema = z4.object({
+var captureClassifierOnlyOutputSchema = z5.object({
   classifier: captureClassifierSchema
 }).strict();
-var captureOutputSchema = z4.union([
+var captureOutputSchema = z5.union([
   captureSuccessOutputSchema,
   captureSinglePreviewOutputSchema,
   captureClassifierOnlyOutputSchema
@@ -1890,40 +2051,40 @@ function buildDataFromFields(fields, descriptionField, descriptionValue) {
 }
 var CAPTURE_ACTIONS = ["capture", "batch"];
 var captureItemSchema = batchCaptureSchema.shape.entries.element;
-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`)."),
+var captureCompoundSchema = z5.object({
+  action: z5.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: 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."),
+  collection: z5.string().max(200).optional().describe("For 'capture': collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional \u2014 classifier auto-routes when omitted."),
+  name: z5.string().max(500).optional().describe("For 'capture': display name \u2014 required for this action."),
+  description: z5.string().max(2e4).optional().describe("For 'capture': full context \u2014 required for this action."),
+  context: z5.string().max(5e3).optional().describe("For 'capture': optional additional context."),
   entryId: entryIdSchema,
-  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')")
+  canonicalKey: z5.string().max(200).optional().describe("For 'capture': semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted."),
+  data: z5.record(z5.unknown()).optional().describe("For 'capture': explicit field values. Merged with inferred values; user-provided wins."),
+  links: z5.array(z5.object({
+    to: z5.string().max(200).describe("Target entry ID (e.g. '<PREFIX>-<n>')"),
+    type: z5.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: 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."),
+  autoCommit: z5.boolean().optional().describe("For 'capture'/'batch': if true, commits immediately after capture + linking."),
+  sourceRef: z5.string().max(2e3).optional().describe("For 'capture': URI or path of the source document backing this entry."),
+  sourceExcerpt: z5.string().max(5e3).optional().describe("For 'capture': verbatim excerpt from the source backing this entry's claims."),
+  preview: z5.boolean().optional().describe("For 'capture'/'batch': if true, validates without writing."),
+  suggestOnly: z5.boolean().optional().describe("For 'capture': if true, runs pre-write grounding and returns a groundingReport WITHOUT creating any entry."),
+  format: z5.enum(["agent", "human"]).optional().describe("For 'capture': response format for grounding data."),
   // For 'batch' — mirrors batchCaptureSchema's `entries`, renamed `items` per §3.
-  items: z4.array(captureItemSchema).min(1).max(50).optional().describe("For 'batch': array of entries to capture, each may carry inline `relations`."),
+  items: z5.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: 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).")
+  ownerTeamEntryId: z5.string().max(200).optional().describe("For 'capture': owning team (rung-2)."),
+  ownerRoleEntryId: z5.string().max(200).optional().describe("For 'capture': owning role (rung-2).")
 });
-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 captureSingleVariant = captureSchema.extend({ action: z5.literal("capture") });
+var captureBatchVariant = z5.object({
+  action: z5.literal("batch"),
+  items: z5.array(captureItemSchema).min(1).max(50),
+  autoCommit: z5.boolean().optional(),
+  preview: z5.boolean().optional()
 });
-var captureActionUnion = z4.discriminatedUnion("action", [
+var captureActionUnion = z5.discriminatedUnion("action", [
   captureSingleVariant,
   captureBatchVariant
 ]);
@@ -2288,6 +2449,7 @@ No DB writes \u2014 call without \`preview:true\` to capture for real.${result2.
     }
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
+    if (isGatewayTimeout(error)) return buildCaptureOutcomeUnknownResult(error, name, msg);
     if (msg.includes("Duplicate") || msg.includes("already exists")) {
       return {
         content: [{
@@ -3328,7 +3490,6 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
       });
       if (job) chunkBytes += prospectiveJobBytes;
     } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
       results.push(buildBatchEntryFailure({
         entryIdx,
         name: entry.name,
@@ -3336,13 +3497,14 @@ async function handleBatchCapture(server, { entries, autoCommit, preview }) {
         classifiedBy,
         confidence,
         confidenceTier,
-        error: msg
+        ...describeBatchEntryOutcome(error, entry.name)
+        // WP-575 review (P1, TEN-1126) — see lib/batchTimeoutCohort.ts.
       }));
     }
   }
   await flushPendingChunk(pendingFinish);
   const created = results.filter((r) => r.ok);
-  const failed = results.filter((r) => !r.ok);
+  const { failed, unknownOutcome: unknownOutcomeEntries } = splitBatchNotOk(results.filter((r) => !r.ok));
   const committed = created.filter((r) => r.status === "committed");
   const proposed = created.filter((r) => r.status === "proposed");
   const drafts = created.filter((r) => r.status === "draft");
@@ -3471,6 +3633,7 @@ _Use \`entries action=move\` to correct any misclassified entries._`);
     lines.push("");
     lines.push(`_If failed > 0, inspect \`failedEntries\` in the structured response and retry individually._`);
   }
+  lines.push(...renderOutcomeUnknownSection(unknownOutcomeEntries));
   const entryIds = created.map((r) => r.entryId);
   if (entryIds.length > 0 || skippedLowConfidence.length > 0) {
     lines.push("");
@@ -3491,7 +3654,7 @@ _Use \`entries action=move\` to correct any misclassified entries._`);
   const skippedNote = skippedLowConfidence.length > 0 ? `, ${skippedLowConfidence.length} skipped (low confidence)` : "";
   const classifiedNote = classifiedCount > 0 ? `, ${classifiedCount} auto-classified` : "";
   const commitFailedNote = commitFailed.length > 0 ? `, ${commitFailed.length} commit-failed` : "";
-  const summary = failed.length > 0 || skippedLowConfidence.length > 0 || commitFailed.length > 0 ? `Batch captured ${created.length}/${entries.length} entries (${failed.length} failed${skippedNote}, ${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft${commitFailedNote}${classifiedNote}).` : `Batch captured ${created.length} entries successfully (${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft${classifiedNote}).`;
+  const summary = failed.length > 0 || unknownOutcomeEntries.length > 0 || skippedLowConfidence.length > 0 || commitFailed.length > 0 ? `Batch captured ${created.length}/${entries.length} entries (${failed.length} failed${unknownOutcomeSummaryNote(unknownOutcomeEntries)}${skippedNote}, ${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft${commitFailedNote}${classifiedNote}).` : `Batch captured ${created.length} entries successfully (${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft${classifiedNote}).`;
   const firstDraft = drafts[0];
   const next = [];
   if (created.length > 0) {
@@ -3566,7 +3729,9 @@ _Use \`entries action=move\` to correct any misclassified entries._`);
               name: r.name,
               error: r.error ?? "unknown error"
             }))
-          }
+          },
+          ...unknownOutcomeEntries.length > 0 && { unknownOutcomeEntries }
+          // WP-575 review (P1, TEN-1126) — kept OUT of failedEntries.
         },
         next
       ),
@@ -3693,9 +3858,9 @@ async function runConflictPreflight(name, description, collectionHint) {
 }
 
 // src/tools/knowledge/getHistory.ts
-import { z as z5 } from "zod/v3";
-var getHistorySchema = z5.object({
-  entryId: z5.string().describe("Entry ID, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'")
+import { z as z6 } from "zod/v3";
+var getHistorySchema = z6.object({
+  entryId: z6.string().describe("Entry ID, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'")
 });
 async function handleGetHistory({ entryId }) {
   const history = await kernelQuery("chain.listEntryHistory", { entryId });
@@ -3754,41 +3919,41 @@ var WORKFLOW_STATUS_VALUES = [
   "evidenced"
 ];
 var LEGACY_WORKFLOW_STATUSES = new Set(WORKFLOW_STATUS_VALUES);
-var updateEntrySchema = z6.object({
-  entryId: z6.string().describe("Entry ID to update, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'"),
-  name: z6.string().optional().describe("New display name"),
-  status: z6.union([
-    z6.enum(["draft", "active", "deprecated", "archived"]),
+var updateEntrySchema = z7.object({
+  entryId: z7.string().describe("Entry ID to update, e.g. 'T-SUPPLIER', '<PREFIX>-<n>'"),
+  name: z7.string().optional().describe("New display name"),
+  status: z7.union([
+    z7.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.
-    z6.enum(WORKFLOW_STATUS_VALUES)
+    z7.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: z6.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: z6.record(z6.unknown()).optional().describe("Fields to update (merged with existing data)"),
-  order: z6.number().optional().describe("New sort order"),
-  canonicalKey: z6.string().optional().describe("Semantic type (e.g. 'decision', 'tension'). Only changeable on draft/uncommitted entries."),
-  autoPublish: z6.boolean().optional().default(false).describe("Only true when user explicitly asks to publish. Default false = draft. Never auto-publish without user confirmation."),
-  changeNote: z6.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: z6.string().optional().describe("URI or path of the source document backing this entry. Write-once: can only be set if currently empty."),
-  sourceExcerpt: z6.string().optional().describe("Verbatim excerpt from the source that backs this entry's claims. Write-once: can only be set if currently empty."),
+  workflowStatus: z7.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: z7.record(z7.unknown()).optional().describe("Fields to update (merged with existing data)"),
+  order: z7.number().optional().describe("New sort order"),
+  canonicalKey: z7.string().optional().describe("Semantic type (e.g. 'decision', 'tension'). Only changeable on draft/uncommitted entries."),
+  autoPublish: z7.boolean().optional().default(false).describe("Only true when user explicitly asks to publish. Default false = draft. Never auto-publish without user confirmation."),
+  changeNote: z7.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: z7.string().optional().describe("URI or path of the source document backing this entry. Write-once: can only be set if currently empty."),
+  sourceExcerpt: z7.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: z6.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: z6.object({
-    response: z6.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
-    entryId: z6.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
-    reason: z6.string().optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
+  steeringOverrideReason: z7.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: z7.object({
+    response: z7.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
+    entryId: z7.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
+    reason: z7.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 commitEntrySchema = z6.object({
-  entryId: z6.string().describe("Entry ID to accept, e.g. 'TEN-abc123', '<PREFIX>-<n>'"),
+var commitEntrySchema = z7.object({
+  entryId: z7.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: z6.boolean().optional().describe("If true, validates the accept without writing. Returns what would happen. Default false."),
+  preview: z7.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: z6.string().optional().describe("Typed override (\u226512 chars) that clears a steering coherency block at the publish chokepoint \u2014 always recorded with author attribution."),
-  coherencyAcknowledgement: z6.object({
-    response: z6.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
-    entryId: z6.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
-    reason: z6.string().optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
+  steeringOverrideReason: z7.string().optional().describe("Typed override (\u226512 chars) that clears a steering coherency block at the publish chokepoint \u2014 always recorded with author attribution."),
+  coherencyAcknowledgement: z7.object({
+    response: z7.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
+    entryId: z7.string().optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
+    reason: z7.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") {
@@ -4177,7 +4342,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 z7 } from "zod/v3";
+import { z as z8 } from "zod/v3";
 
 // src/lib/resolve-project-root.ts
 import { existsSync } from "fs";
@@ -4329,12 +4494,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 = z7.object({
-  collection: z7.string().max(200).default("glossary").describe("Collection slug to verify (default: glossary)"),
-  mode: z7.enum(["report", "fix"]).default("report").describe("'report' = read-only trust report. 'fix' = also update drifted codeMapping statuses.")
+var verifySchema = z8.object({
+  collection: z8.string().max(200).default("glossary").describe("Collection slug to verify (default: glossary)"),
+  mode: z8.enum(["report", "fix"]).default("report").describe("'report' = read-only trust report. 'fix' = also update drifted codeMapping statuses.")
 });
-var verifyEntrySchema = z7.object({
-  entryId: z7.string().max(200).describe("Human entry ID (e.g. '<PREFIX>-<n>') to mark as verified")
+var verifyEntrySchema = z8.object({
+  entryId: z8.string().max(200).describe("Human entry ID (e.g. '<PREFIX>-<n>') to mark as verified")
 });
 async function handleVerifyChain(server, { collection, mode }) {
   const projectRoot = resolveProjectRoot();
@@ -4551,10 +4716,10 @@ async function handleVerifyEntry({ entryId }) {
 }
 
 // src/tools/entry-move.ts
-import { z as z8 } from "zod/v3";
-var moveEntrySchema = z8.object({
-  entryId: z8.string().describe("Entry ID to move, e.g. '<PREFIX>-<n>'"),
-  toCollection: z8.string().describe("Target collection slug, e.g. 'decisions', 'architecture'")
+import { z as z9 } from "zod/v3";
+var moveEntrySchema = z9.object({
+  entryId: z9.string().describe("Entry ID to move, e.g. '<PREFIX>-<n>'"),
+  toCollection: z9.string().describe("Target collection slug, e.g. 'decisions', 'architecture'")
 });
 async function handleMoveEntry(entryId, toCollection) {
   try {
@@ -4665,89 +4830,89 @@ var ENTRIES_ACTIONS = [
   "move",
   "verify"
 ];
-var coherencyAcknowledgementFlatSchema = z9.object({
-  response: z9.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
-  entryId: z9.string().max(200).optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
-  reason: z9.string().max(2e3).optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
+var coherencyAcknowledgementFlatSchema = z10.object({
+  response: z10.enum(["linked", "accepted-fix", "diverged"]).describe("Explicit response to an acknowledge-required coherency challenge."),
+  entryId: z10.string().max(200).optional().describe("Authorizing entry being linked/accepted (required for 'linked' and 'accepted-fix')."),
+  reason: z10.string().max(2e3).optional().describe("Divergence rationale (required for 'diverged', \u226512 chars).")
 });
-var entriesSchema = z9.object({
-  action: z9.enum(ENTRIES_ACTIONS).describe(
+var entriesSchema = z10.object({
+  action: z10.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: z9.string().max(200).optional().describe(
+  entryId: z10.string().max(200).optional().describe(
     "Entry ID, e.g. '<PREFIX>-<n>'. Required for: get, update, commit, history, move, verify."
   ),
-  entryIds: z9.array(z9.string().max(200)).min(1).max(20).optional().describe("Entry IDs for 'batch', e.g. ['TYPE-strategy', 'STR-jljeg7']"),
-  collection: z9.string().max(200).optional().describe("Collection slug \u2014 for 'list'/'search': scope filter, e.g. 'glossary', 'tracking-events'."),
-  status: z9.string().max(200).optional().describe(
+  entryIds: z10.array(z10.string().max(200)).min(1).max(20).optional().describe("Entry IDs for 'batch', e.g. ['TYPE-strategy', 'STR-jljeg7']"),
+  collection: z10.string().max(200).optional().describe("Collection slug \u2014 for 'list'/'search': scope filter, e.g. 'glossary', 'tracking-events'."),
+  status: z10.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: z9.string().max(200).optional().describe("For 'list': filter by internal tag."),
-  label: z9.string().max(200).optional().describe("For 'list': filter by label slug \u2014 matches entries across all collections."),
-  query: z9.string().min(2).max(500).optional().describe("For 'search': search text (min 2 characters)."),
-  name: z9.string().max(500).optional().describe("For 'update': new display name."),
-  workflowStatus: z9.string().max(200).optional().describe(
+  tag: z10.string().max(200).optional().describe("For 'list': filter by internal tag."),
+  label: z10.string().max(200).optional().describe("For 'list': filter by label slug \u2014 matches entries across all collections."),
+  query: z10.string().min(2).max(500).optional().describe("For 'search': search text (min 2 characters)."),
+  name: z10.string().max(500).optional().describe("For 'update': new display name."),
+  workflowStatus: z10.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: z9.record(z9.unknown()).optional().describe("For 'update': fields to update (merged with existing data)."),
-  order: z9.number().optional().describe("For 'update': new sort order."),
-  canonicalKey: z9.string().max(200).optional().describe(
+  data: z10.record(z10.unknown()).optional().describe("For 'update': fields to update (merged with existing data)."),
+  order: z10.number().optional().describe("For 'update': new sort order."),
+  canonicalKey: z10.string().max(200).optional().describe(
     "For 'update': semantic type (e.g. 'decision', 'tension'). Only changeable on draft/uncommitted entries."
   ),
-  autoPublish: z9.boolean().optional().default(false).describe(
+  autoPublish: z10.boolean().optional().default(false).describe(
     "For 'update': only true when the user explicitly asks to publish. Default false = draft."
   ),
-  changeNote: z9.string().max(2e3).optional().describe(
+  changeNote: z10.string().max(2e3).optional().describe(
     "For 'update': short human-readable rationale for WHY this change was made. Surfaces in activity feed."
   ),
-  sourceRef: z9.string().max(2e3).optional().describe(
+  sourceRef: z10.string().max(2e3).optional().describe(
     "For 'update': URI or path of the source document backing this entry. Write-once."
   ),
-  sourceExcerpt: z9.string().max(5e3).optional().describe(
+  sourceExcerpt: z10.string().max(5e3).optional().describe(
     "For 'update': verbatim excerpt from the source backing this entry's claims. Write-once."
   ),
-  steeringOverrideReason: z9.string().max(2e3).optional().describe(
+  steeringOverrideReason: z10.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: z9.boolean().optional().describe(
+  preview: z10.boolean().optional().describe(
     "For 'commit': if true, validates the accept without writing \u2014 returns what would happen."
   ),
-  toCollection: z9.string().max(200).optional().describe("For 'move': target collection slug, e.g. 'decisions', 'architecture'.")
+  toCollection: z10.string().max(200).optional().describe("For 'move': target collection slug, e.g. 'decisions', 'architecture'.")
 });
-var entriesListVariant = z9.object({
-  action: z9.literal("list"),
-  collection: z9.string().max(200).optional(),
-  status: z9.string().max(200).optional(),
-  tag: z9.string().max(200).optional(),
-  label: z9.string().max(200).optional()
+var entriesListVariant = z10.object({
+  action: z10.literal("list"),
+  collection: z10.string().max(200).optional(),
+  status: z10.string().max(200).optional(),
+  tag: z10.string().max(200).optional(),
+  label: z10.string().max(200).optional()
 });
-var entriesGetVariant = z9.object({
-  action: z9.literal("get"),
-  entryId: z9.string().max(200)
+var entriesGetVariant = z10.object({
+  action: z10.literal("get"),
+  entryId: z10.string().max(200)
 });
-var entriesBatchVariant = z9.object({
-  action: z9.literal("batch"),
-  entryIds: z9.array(z9.string().max(200)).min(1).max(20)
+var entriesBatchVariant = z10.object({
+  action: z10.literal("batch"),
+  entryIds: z10.array(z10.string().max(200)).min(1).max(20)
 });
-var entriesSearchVariant = z9.object({
-  action: z9.literal("search"),
-  query: z9.string().min(2).max(500),
-  collection: z9.string().max(200).optional(),
-  status: z9.string().max(200).optional()
+var entriesSearchVariant = z10.object({
+  action: z10.literal("search"),
+  query: z10.string().min(2).max(500),
+  collection: z10.string().max(200).optional(),
+  status: z10.string().max(200).optional()
 });
-var entriesUpdateVariant = updateEntrySchema.extend({ action: z9.literal("update") });
-var entriesCommitVariant = commitEntrySchema.extend({ action: z9.literal("commit") });
-var entriesHistoryVariant = getHistorySchema.extend({ action: z9.literal("history") });
-var entriesMoveVariant = z9.object({
-  action: z9.literal("move"),
-  entryId: z9.string().max(200),
-  toCollection: z9.string().max(200)
+var entriesUpdateVariant = updateEntrySchema.extend({ action: z10.literal("update") });
+var entriesCommitVariant = commitEntrySchema.extend({ action: z10.literal("commit") });
+var entriesHistoryVariant = getHistorySchema.extend({ action: z10.literal("history") });
+var entriesMoveVariant = z10.object({
+  action: z10.literal("move"),
+  entryId: z10.string().max(200),
+  toCollection: z10.string().max(200)
 });
-var entriesVerifyVariant = verifyEntrySchema.extend({ action: z9.literal("verify") });
-var entriesActionUnion = z9.discriminatedUnion("action", [
+var entriesVerifyVariant = verifyEntrySchema.extend({ action: z10.literal("verify") });
+var entriesActionUnion = z10.discriminatedUnion("action", [
   entriesListVariant,
   entriesGetVariant,
   entriesBatchVariant,
@@ -4769,15 +4934,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 = z9.object({
-  entryId: z9.string(),
-  name: z9.string(),
-  collection: z9.string(),
-  status: z9.string(),
-  capturedAt: z9.number().optional(),
-  origin: z9.string().optional(),
-  originDetail: z9.string().optional(),
-  verificationStatus: z9.string().optional(),
+var entriesGetOutputSchema = z10.object({
+  entryId: z10.string(),
+  name: z10.string(),
+  collection: z10.string(),
+  status: z10.string(),
+  capturedAt: z10.number().optional(),
+  origin: z10.string().optional(),
+  originDetail: z10.string().optional(),
+  verificationStatus: z10.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.
@@ -4786,72 +4951,72 @@ var entriesGetOutputSchema = z9.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: z9.string().optional(),
-  attestation: z9.object({
-    strength: z9.enum(["human-direct", "delegated", "system", "unattested"]),
-    basis: z9.string().optional()
+  verifiedBy: z10.string().optional(),
+  attestation: z10.object({
+    strength: z10.enum(["human-direct", "delegated", "system", "unattested"]),
+    basis: z10.string().optional()
   }).optional(),
-  sourceRef: z9.string().optional(),
-  sourceExcerpt: z9.string().optional(),
-  why: z9.string().optional(),
+  sourceRef: z10.string().optional(),
+  sourceExcerpt: z10.string().optional(),
+  why: z10.string().optional(),
   // TEN-2191: quality of the captured WHY — 'rationale' | 'missing' | 'restated'.
-  whyQuality: z9.enum(["rationale", "missing", "restated"]).optional(),
-  data: z9.record(z9.unknown()).optional(),
-  relations: z9.array(z9.object({
-    entryId: z9.string().optional(),
-    name: z9.string(),
-    type: z9.string(),
-    direction: z9.string()
+  whyQuality: z10.enum(["rationale", "missing", "restated"]).optional(),
+  data: z10.record(z10.unknown()).optional(),
+  relations: z10.array(z10.object({
+    entryId: z10.string().optional(),
+    name: z10.string(),
+    type: z10.string(),
+    direction: z10.string()
   })).optional(),
-  labels: z9.array(z9.string()).optional()
+  labels: z10.array(z10.string()).optional()
 }).passthrough();
-var entriesListOutputSchema = z9.object({
-  entries: z9.array(z9.object({
-    entryId: z9.string(),
-    name: z9.string(),
-    collection: z9.string(),
-    status: z9.string()
+var entriesListOutputSchema = z10.object({
+  entries: z10.array(z10.object({
+    entryId: z10.string(),
+    name: z10.string(),
+    collection: z10.string(),
+    status: z10.string()
   })),
-  total: z9.number()
+  total: z10.number()
 });
-var entriesSearchOutputSchema = z9.object({
-  results: z9.array(z9.object({
-    entryId: z9.string(),
-    name: z9.string(),
-    collection: z9.string(),
-    status: z9.string(),
-    score: z9.number().optional()
+var entriesSearchOutputSchema = z10.object({
+  results: z10.array(z10.object({
+    entryId: z10.string(),
+    name: z10.string(),
+    collection: z10.string(),
+    status: z10.string(),
+    score: z10.number().optional()
   })),
-  total: z9.number(),
-  query: z9.string()
+  total: z10.number(),
+  query: z10.string()
 });
-var entriesBatchOutputSchema = z9.object({
-  entries: z9.array(z9.object({
-    entryId: z9.string(),
-    name: z9.string(),
-    collection: z9.string(),
-    status: z9.string(),
-    capturedAt: z9.number().optional(),
-    origin: z9.string().optional(),
-    originDetail: z9.string().optional(),
-    verificationStatus: z9.string().optional(),
+var entriesBatchOutputSchema = z10.object({
+  entries: z10.array(z10.object({
+    entryId: z10.string(),
+    name: z10.string(),
+    collection: z10.string(),
+    status: z10.string(),
+    capturedAt: z10.number().optional(),
+    origin: z10.string().optional(),
+    originDetail: z10.string().optional(),
+    verificationStatus: z10.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: z9.string().optional(),
-    attestation: z9.object({
-      strength: z9.enum(["human-direct", "delegated", "system", "unattested"]),
-      basis: z9.string().optional()
+    verifiedBy: z10.string().optional(),
+    attestation: z10.object({
+      strength: z10.enum(["human-direct", "delegated", "system", "unattested"]),
+      basis: z10.string().optional()
     }).optional(),
-    sourceRef: z9.string().optional(),
-    sourceExcerpt: z9.string().optional(),
+    sourceRef: z10.string().optional(),
+    sourceExcerpt: z10.string().optional(),
     // TEN-2191: mirror entriesGetOutputSchema — batch entries now carry why/whyQuality.
-    why: z9.string().optional(),
-    whyQuality: z9.enum(["rationale", "missing", "restated"]).optional(),
-    data: z9.record(z9.unknown()).optional()
+    why: z10.string().optional(),
+    whyQuality: z10.enum(["rationale", "missing", "restated"]).optional(),
+    data: z10.record(z10.unknown()).optional()
   }).passthrough()),
-  total: z9.number()
+  total: z10.number()
 });
 function registerEntriesTools(server) {
   const entriesHandlers = {
@@ -5243,41 +5408,41 @@ ${footer}` }],
 }
 
 // src/tools/relations.ts
-import { z as z11 } from "zod/v3";
+import { z as z12 } from "zod/v3";
 
 // src/tools/graph.ts
-import { z as z10 } from "zod/v3";
+import { z as z11 } from "zod/v3";
 var GRAPH_ACTIONS = ["find", "suggest"];
-var graphSchema = z10.object({
-  action: z10.enum(GRAPH_ACTIONS).describe(
+var graphSchema = z11.object({
+  action: z11.enum(GRAPH_ACTIONS).describe(
     "'find': traverse relations from an entry (graph walk). 'suggest': discover potential connections for an entry."
   ),
-  entryId: z10.string().max(200).describe("Entry ID, e.g. '<PREFIX>-<n>'"),
-  direction: z10.enum(["incoming", "outgoing", "both"]).default("both").optional().describe("For find: 'incoming' = what references this, 'outgoing' = what this references"),
-  limit: z10.number().min(1).max(20).default(10).optional().describe("For suggest: max suggestions to return"),
-  depth: z10.number().min(1).max(3).default(2).optional().describe("For suggest: graph traversal depth")
+  entryId: z11.string().max(200).describe("Entry ID, e.g. '<PREFIX>-<n>'"),
+  direction: z11.enum(["incoming", "outgoing", "both"]).default("both").optional().describe("For find: 'incoming' = what references this, 'outgoing' = what this references"),
+  limit: z11.number().min(1).max(20).default(10).optional().describe("For suggest: max suggestions to return"),
+  depth: z11.number().min(1).max(3).default(2).optional().describe("For suggest: graph traversal depth")
 });
-var graphFindOutputSchema = z10.object({
-  entryId: z10.string(),
-  relations: z10.array(z10.object({
-    entryId: z10.string().optional(),
-    name: z10.string(),
-    type: z10.string(),
-    direction: z10.enum(["outgoing", "incoming"])
+var graphFindOutputSchema = z11.object({
+  entryId: z11.string(),
+  relations: z11.array(z11.object({
+    entryId: z11.string().optional(),
+    name: z11.string(),
+    type: z11.string(),
+    direction: z11.enum(["outgoing", "incoming"])
   })),
-  total: z10.number()
+  total: z11.number()
 });
-var graphSuggestOutputSchema = z10.object({
-  entryId: z10.string(),
-  suggestions: z10.array(z10.object({
-    targetEntryId: z10.string().optional(),
-    targetName: z10.string(),
-    relationType: z10.string(),
-    direction: z10.string(),
-    confidence: z10.number(),
-    reason: z10.string()
+var graphSuggestOutputSchema = z11.object({
+  entryId: z11.string(),
+  suggestions: z11.array(z11.object({
+    targetEntryId: z11.string().optional(),
+    targetName: z11.string(),
+    relationType: z11.string(),
+    direction: z11.string(),
+    confidence: z11.number(),
+    reason: z11.string()
   })),
-  total: z10.number()
+  total: z11.number()
 });
 async function handleFind(entryId, direction) {
   const relations = await kernelQuery("chain.listEntryRelations", { entryId });
@@ -5468,64 +5633,64 @@ async function handleSuggest(entryId, limit, depth) {
 
 // src/tools/relations.ts
 var RELATIONS_ACTIONS = ["create", "batch-create", "dismiss", "delete", "find", "suggest"];
-var relationItemSchema = z11.object({
-  from: z11.string().max(200),
-  to: z11.string().max(200),
-  type: z11.string().max(200)
+var relationItemSchema = z12.object({
+  from: z12.string().max(200),
+  to: z12.string().max(200),
+  type: z12.string().max(200)
 });
-var relationsSchema = z11.object({
-  action: z11.enum(RELATIONS_ACTIONS).describe(
+var relationsSchema = z12.object({
+  action: z12.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: z11.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': source entry ID."),
-  to: z11.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': target entry ID."),
-  type: z11.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': relation type."),
-  score: z11.number().optional().describe("For 'dismiss': suggestion score from action=suggest."),
-  relations: z11.array(relationItemSchema).min(1).max(20).optional().describe("For 'batch-create': array of {from, to, type}."),
+  from: z12.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': source entry ID."),
+  to: z12.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': target entry ID."),
+  type: z12.string().max(200).optional().describe("For 'create'/'dismiss'/'delete': relation type."),
+  score: z12.number().optional().describe("For 'dismiss': suggestion score from action=suggest."),
+  relations: z12.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: z11.boolean().optional().describe("For 'create': if true, validates the relation without writing. Returns what would happen. Default false."),
-  entryId: z11.string().max(200).optional().describe("For 'find'/'suggest': entry ID, e.g. '<PREFIX>-<n>'."),
-  direction: z11.enum(["incoming", "outgoing", "both"]).optional().describe("For 'find': 'incoming' = what references this, 'outgoing' = what this references. Default 'both'."),
-  limit: z11.number().min(1).max(20).optional().describe("For 'suggest': max suggestions to return. Default 10."),
-  depth: z11.number().min(1).max(3).optional().describe("For 'suggest': graph traversal depth. Default 2.")
+  preview: z12.boolean().optional().describe("For 'create': if true, validates the relation without writing. Returns what would happen. Default false."),
+  entryId: z12.string().max(200).optional().describe("For 'find'/'suggest': entry ID, e.g. '<PREFIX>-<n>'."),
+  direction: z12.enum(["incoming", "outgoing", "both"]).optional().describe("For 'find': 'incoming' = what references this, 'outgoing' = what this references. Default 'both'."),
+  limit: z12.number().min(1).max(20).optional().describe("For 'suggest': max suggestions to return. Default 10."),
+  depth: z12.number().min(1).max(3).optional().describe("For 'suggest': graph traversal depth. Default 2.")
 });
-var relationsCreateVariant = z11.object({
-  action: z11.literal("create"),
-  from: z11.string().max(200),
-  to: z11.string().max(200),
-  type: z11.string().max(200),
-  score: z11.number().optional(),
-  preview: z11.boolean().optional()
+var relationsCreateVariant = z12.object({
+  action: z12.literal("create"),
+  from: z12.string().max(200),
+  to: z12.string().max(200),
+  type: z12.string().max(200),
+  score: z12.number().optional(),
+  preview: z12.boolean().optional()
 });
-var relationsBatchCreateVariant = z11.object({
-  action: z11.literal("batch-create"),
-  relations: z11.array(relationItemSchema).min(1).max(20)
+var relationsBatchCreateVariant = z12.object({
+  action: z12.literal("batch-create"),
+  relations: z12.array(relationItemSchema).min(1).max(20)
 });
-var relationsDismissVariant = z11.object({
-  action: z11.literal("dismiss"),
-  from: z11.string().max(200),
-  to: z11.string().max(200),
-  type: z11.string().max(200).optional(),
-  score: z11.number().optional()
+var relationsDismissVariant = z12.object({
+  action: z12.literal("dismiss"),
+  from: z12.string().max(200),
+  to: z12.string().max(200),
+  type: z12.string().max(200).optional(),
+  score: z12.number().optional()
 });
-var relationsDeleteVariant = z11.object({
-  action: z11.literal("delete"),
-  from: z11.string().max(200),
-  to: z11.string().max(200),
-  type: z11.string().max(200)
+var relationsDeleteVariant = z12.object({
+  action: z12.literal("delete"),
+  from: z12.string().max(200),
+  to: z12.string().max(200),
+  type: z12.string().max(200)
 });
-var relationsFindVariant = z11.object({
-  action: z11.literal("find"),
-  entryId: z11.string().max(200),
-  direction: z11.enum(["incoming", "outgoing", "both"]).optional().default("both")
+var relationsFindVariant = z12.object({
+  action: z12.literal("find"),
+  entryId: z12.string().max(200),
+  direction: z12.enum(["incoming", "outgoing", "both"]).optional().default("both")
 });
-var relationsSuggestVariant = z11.object({
-  action: z11.literal("suggest"),
-  entryId: z11.string().max(200),
-  limit: z11.number().min(1).max(20).optional().default(10),
-  depth: z11.number().min(1).max(3).optional().default(2)
+var relationsSuggestVariant = z12.object({
+  action: z12.literal("suggest"),
+  entryId: z12.string().max(200),
+  limit: z12.number().min(1).max(20).optional().default(10),
+  depth: z12.number().min(1).max(3).optional().default(2)
 });
-var relationsActionUnion = z11.discriminatedUnion("action", [
+var relationsActionUnion = z12.discriminatedUnion("action", [
   relationsCreateVariant,
   relationsBatchCreateVariant,
   relationsDismissVariant,
@@ -5821,19 +5986,19 @@ async function handleDelete(from, to, type) {
 }
 
 // src/tools/context.ts
-import { z as z13 } from "zod/v3";
+import { z as z14 } from "zod/v3";
 
 // src/tools/documents.ts
-import { z as z12 } from "zod/v3";
+import { z as z13 } from "zod/v3";
 var DOCUMENTS_ACTIONS = ["get-last-verified-brief"];
-var documentsSchema = z12.object({
-  action: z12.enum(DOCUMENTS_ACTIONS).describe(
+var documentsSchema = z13.object({
+  action: z13.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: z12.string().max(200).describe(
+  templateId: z13.string().max(200).describe(
     "Brief template identifier \u2014 currently 'steering-brief' is the only registered template."
   ),
-  scopeKey: z12.string().max(200).describe(
+  scopeKey: z13.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."
   )
 });
@@ -5913,89 +6078,89 @@ function epistemicCollectionHint(collectionName) {
   return "";
 }
 var CONTEXT_ACTIONS = ["gather", "build", "neighborhood", "changes", "chain", "cross-cut", "incremental", "brief", "last-verified-brief"];
-var contextSchema = z13.object({
+var contextSchema = z14.object({
   // provenance: neighborhood BET-142; changes/chain/cross-cut/incremental/brief BET-239 (E4, E6)
-  action: z13.enum(CONTEXT_ACTIONS).describe(
+  action: z14.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: z13.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: z13.string().max(200).optional().describe(
+  entryId: z14.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: z14.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: z13.string().max(2e3).optional().describe("For 'gather': natural-language task description for loading task-relevant governance, binding constraints, and supporting context."),
-  since: z13.string().max(200).optional().describe(
+  task: z14.string().max(2e3).optional().describe("For 'gather': natural-language task description for loading task-relevant governance, binding constraints, and supporting context."),
+  since: z14.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: z13.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: z13.string().max(200).optional().describe(
+  direction: z14.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: z14.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: z13.enum(["search", "graph"]).default("search").optional().describe("For gather: 'search' (default) or 'graph' (enhanced with provenance paths). Ignored when mapEntryId is provided."),
-  maxHops: z13.number().min(1).max(4).default(2).describe("Relation traversal depth (1=direct only, 2=default, 3=wide net, 4=deep chain walk)"),
-  maxResults: z13.number().min(1).max(25).default(10).optional().describe("Max entries to return in gather task mode (default 10)"),
-  strategy: z13.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: z13.string().max(200).optional().describe(
+  mode: z14.enum(["search", "graph"]).default("search").optional().describe("For gather: 'search' (default) or 'graph' (enhanced with provenance paths). Ignored when mapEntryId is provided."),
+  maxHops: z14.number().min(1).max(4).default(2).describe("Relation traversal depth (1=direct only, 2=default, 3=wide net, 4=deep chain walk)"),
+  maxResults: z14.number().min(1).max(25).default(10).optional().describe("Max entries to return in gather task mode (default 10)"),
+  strategy: z14.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: z14.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: z13.enum(["steering", "confidence", "delta"]).optional().describe(
+  briefType: z14.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: z13.string().max(200).optional().describe(
+  templateId: z14.string().max(200).optional().describe(
     "For 'last-verified-brief': brief template identifier \u2014 currently 'steering-brief' is the only registered template."
   ),
-  scopeKey: z13.string().max(200).optional().describe(
+  scopeKey: z14.string().max(200).optional().describe(
     "For 'last-verified-brief': canonical scope key \u2014 'workspace:<workspaceId>' or 'initiative:<INI-ID>'."
   )
 });
-var contextGatherVariant = z13.object({
-  action: z13.literal("gather"),
-  entryId: z13.string().max(200).optional(),
-  mapEntryId: z13.string().max(200).optional(),
-  task: z13.string().max(2e3).optional(),
-  mode: z13.enum(["search", "graph"]).optional().default("search"),
-  maxHops: z13.number().min(1).max(4).optional().default(2),
-  maxResults: z13.number().min(1).max(25).optional().default(10),
-  strategy: z13.enum(["hybrid", "keyword"]).optional().default("keyword")
+var contextGatherVariant = z14.object({
+  action: z14.literal("gather"),
+  entryId: z14.string().max(200).optional(),
+  mapEntryId: z14.string().max(200).optional(),
+  task: z14.string().max(2e3).optional(),
+  mode: z14.enum(["search", "graph"]).optional().default("search"),
+  maxHops: z14.number().min(1).max(4).optional().default(2),
+  maxResults: z14.number().min(1).max(25).optional().default(10),
+  strategy: z14.enum(["hybrid", "keyword"]).optional().default("keyword")
 });
-var contextBuildVariant = z13.object({
-  action: z13.literal("build"),
-  entryId: z13.string().max(200),
-  maxHops: z13.number().min(1).max(4).optional().default(2)
+var contextBuildVariant = z14.object({
+  action: z14.literal("build"),
+  entryId: z14.string().max(200),
+  maxHops: z14.number().min(1).max(4).optional().default(2)
 });
-var contextNeighborhoodVariant = z13.object({
-  action: z13.literal("neighborhood"),
-  entryId: z13.string().max(200)
+var contextNeighborhoodVariant = z14.object({
+  action: z14.literal("neighborhood"),
+  entryId: z14.string().max(200)
 });
-var contextChangesVariant = z13.object({
-  action: z13.literal("changes"),
-  since: z13.string().max(200)
+var contextChangesVariant = z14.object({
+  action: z14.literal("changes"),
+  since: z14.string().max(200)
 });
-var contextChainVariant = z13.object({
-  action: z13.literal("chain"),
-  entryId: z13.string().max(200),
-  direction: z13.enum(["outgoing", "incoming"]).optional().default("outgoing"),
-  maxHops: z13.number().min(1).max(4).optional().default(2),
-  relationType: z13.string().max(200).optional()
+var contextChainVariant = z14.object({
+  action: z14.literal("chain"),
+  entryId: z14.string().max(200),
+  direction: z14.enum(["outgoing", "incoming"]).optional().default("outgoing"),
+  maxHops: z14.number().min(1).max(4).optional().default(2),
+  relationType: z14.string().max(200).optional()
 });
-var contextCrossCutVariant = z13.object({
-  action: z13.literal("cross-cut"),
-  relationType: z13.string().max(200)
+var contextCrossCutVariant = z14.object({
+  action: z14.literal("cross-cut"),
+  relationType: z14.string().max(200)
 });
-var contextIncrementalVariant = z13.object({
-  action: z13.literal("incremental"),
-  skill: z13.string().max(200)
+var contextIncrementalVariant = z14.object({
+  action: z14.literal("incremental"),
+  skill: z14.string().max(200)
 });
-var contextBriefVariant = z13.object({
-  action: z13.literal("brief"),
-  briefType: z13.enum(["steering", "confidence", "delta"]),
-  since: z13.string().max(200).optional()
+var contextBriefVariant = z14.object({
+  action: z14.literal("brief"),
+  briefType: z14.enum(["steering", "confidence", "delta"]),
+  since: z14.string().max(200).optional()
 });
-var contextLastVerifiedBriefVariant = z13.object({
-  action: z13.literal("last-verified-brief"),
-  templateId: z13.string().max(200),
-  scopeKey: z13.string().max(200)
+var contextLastVerifiedBriefVariant = z14.object({
+  action: z14.literal("last-verified-brief"),
+  templateId: z14.string().max(200),
+  scopeKey: z14.string().max(200)
 });
-var contextActionUnion = z13.discriminatedUnion("action", [
+var contextActionUnion = z14.discriminatedUnion("action", [
   contextGatherVariant,
   contextBuildVariant,
   contextNeighborhoodVariant,
@@ -7036,20 +7201,20 @@ function formatTimeAgo(ms) {
 }
 
 // src/tools/collections.ts
-import { z as z15 } from "zod/v3";
+import { z as z16 } from "zod/v3";
 
 // src/tools/labels.ts
-import { z as z14 } from "zod/v3";
-var labelsSchema = z14.object({
-  action: z14.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: z14.string().max(200).optional().describe("Label slug (required for create/update/delete/apply/remove)"),
-  name: z14.string().max(500).optional().describe("Display name (required for create)"),
-  color: z14.string().max(50).optional().describe("Hex color, e.g. '#ef4444'"),
-  description: z14.string().max(2e3).optional().describe("What this label means"),
-  parentSlug: z14.string().max(200).optional().describe("Parent group slug for label hierarchy"),
-  isGroup: z14.boolean().optional().describe("True if this is a group container, not a taggable label"),
-  order: z14.number().optional().describe("Sort order within its group"),
-  entryId: z14.string().max(200).optional().describe("Entry ID for apply/remove actions")
+import { z as z15 } from "zod/v3";
+var labelsSchema = z15.object({
+  action: z15.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: z15.string().max(200).optional().describe("Label slug (required for create/update/delete/apply/remove)"),
+  name: z15.string().max(500).optional().describe("Display name (required for create)"),
+  color: z15.string().max(50).optional().describe("Hex color, e.g. '#ef4444'"),
+  description: z15.string().max(2e3).optional().describe("What this label means"),
+  parentSlug: z15.string().max(200).optional().describe("Parent group slug for label hierarchy"),
+  isGroup: z15.boolean().optional().describe("True if this is a group container, not a taggable label"),
+  order: z15.number().optional().describe("Sort order within its group"),
+  entryId: z15.string().max(200).optional().describe("Entry ID for apply/remove actions")
 });
 async function handleLabelsList() {
   const labels = await kernelQuery("chain.listLabels");
@@ -7154,128 +7319,128 @@ var COLLECTIONS_ACTIONS = [
   "label-apply",
   "label-remove"
 ];
-var qualityCriterionSchema = z15.object({
-  field: z15.string().max(200).describe("Entry data field key this criterion applies to, e.g. 'description', 'owner'"),
+var qualityCriterionSchema = z16.object({
+  field: z16.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: z15.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: z15.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: z16.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: z16.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 = z15.object({
-  key: z15.string().max(200).describe("Field key, e.g. 'description', 'severity', 'status'"),
-  label: z15.string().max(200).describe("Display label, e.g. 'Description', 'Severity'"),
-  type: z15.string().max(50).describe("Field type: 'string', 'select', 'array', 'number', 'boolean'"),
-  required: z15.boolean().optional().describe("Whether this field is required"),
-  options: z15.array(z15.string().max(200)).max(200).optional().describe("Options for 'select' type fields"),
-  searchable: z15.boolean().optional().describe("Whether this field is included in full-text search"),
-  displayHint: z15.enum(["hero", "badge", "meta", "section", "hidden", "inline-meta"]).optional().describe("V2 rendering hint: how the field should be displayed in Cortex"),
-  zone: z15.enum(["header", "body", "meta"]).optional().describe("V2 layout zone: where the field appears in the entry view"),
-  colorMap: z15.record(z15.string().max(50)).optional().describe("V2 value-to-semantic-color mapping, e.g. { critical: 'danger', low: 'success' }"),
+var fieldSchema = z16.object({
+  key: z16.string().max(200).describe("Field key, e.g. 'description', 'severity', 'status'"),
+  label: z16.string().max(200).describe("Display label, e.g. 'Description', 'Severity'"),
+  type: z16.string().max(50).describe("Field type: 'string', 'select', 'array', 'number', 'boolean'"),
+  required: z16.boolean().optional().describe("Whether this field is required"),
+  options: z16.array(z16.string().max(200)).max(200).optional().describe("Options for 'select' type fields"),
+  searchable: z16.boolean().optional().describe("Whether this field is included in full-text search"),
+  displayHint: z16.enum(["hero", "badge", "meta", "section", "hidden", "inline-meta"]).optional().describe("V2 rendering hint: how the field should be displayed in Cortex"),
+  zone: z16.enum(["header", "body", "meta"]).optional().describe("V2 layout zone: where the field appears in the entry view"),
+  colorMap: z16.record(z16.string().max(50)).optional().describe("V2 value-to-semantic-color mapping, e.g. { critical: 'danger', low: 'success' }"),
   // ENT-61
-  accentSource: z15.boolean().optional().describe("When true, this field's colorMap value drives the card-level accent styling"),
+  accentSource: z16.boolean().optional().describe("When true, this field's colorMap value drives the card-level accent styling"),
   // ENT-61
-  iconMap: z15.record(z15.string(), z15.string().max(50)).optional().describe("Maps field values to icons (emoji/symbol), prepended to badge text"),
-  helpText: z15.string().max(2e3).optional().describe("Help text shown in editors and describe output"),
-  optionDescriptions: z15.record(z15.string().max(500)).optional().describe("Per-option guidance for select fields"),
+  iconMap: z16.record(z16.string(), z16.string().max(50)).optional().describe("Maps field values to icons (emoji/symbol), prepended to badge text"),
+  helpText: z16.string().max(2e3).optional().describe("Help text shown in editors and describe output"),
+  optionDescriptions: z16.record(z16.string().max(500)).optional().describe("Per-option guidance for select fields"),
   // BET-136
-  semanticRole: z15.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: z16.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: z15.number().optional().describe("Maximum character length for field values. Three-tier resolution: explicit > displayHint > type fallback."),
+  maxLength: z16.number().optional().describe("Maximum character length for field values. Three-tier resolution: explicit > displayHint > type fallback."),
   // BET-196
-  minLength: z15.number().optional().describe("Minimum character length for field values. Only explicit \u2014 no defaults.")
+  minLength: z16.number().optional().describe("Minimum character length for field values. Only explicit \u2014 no defaults.")
 });
-var collectionsSchema = z15.object({
-  action: z15.enum(COLLECTIONS_ACTIONS).describe(
+var collectionsSchema = z16.object({
+  action: z16.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: z15.string().max(200).optional().describe("URL-safe identifier for create/update, e.g. 'glossary', 'tech-debt'. For label-*: label slug."),
-  name: z15.string().max(500).optional().describe("Display name for create, or new name for update. For label-create: label display name."),
-  description: z15.string().max(2e4).optional().describe("What this collection is for. For label-create/label-update: what the label means."),
-  purpose: z15.string().max(2e3).optional().describe("Why this collection exists \u2014 strategic reason"),
-  icon: z15.string().max(50).optional().describe("Emoji icon for the collection"),
-  navGroup: z15.enum(["daily", "strategic", "governance", "reference", "collections"]).optional().describe("Sidebar placement: 'daily', 'strategic', 'governance', 'reference', 'collections'"),
-  fields: z15.array(fieldSchema).max(200).optional().describe("Field definitions for create, or replacement schema for update (replaces all fields)"),
+  slug: z16.string().max(200).optional().describe("URL-safe identifier for create/update, e.g. 'glossary', 'tech-debt'. For label-*: label slug."),
+  name: z16.string().max(500).optional().describe("Display name for create, or new name for update. For label-create: label display name."),
+  description: z16.string().max(2e4).optional().describe("What this collection is for. For label-create/label-update: what the label means."),
+  purpose: z16.string().max(2e3).optional().describe("Why this collection exists \u2014 strategic reason"),
+  icon: z16.string().max(50).optional().describe("Emoji icon for the collection"),
+  navGroup: z16.enum(["daily", "strategic", "governance", "reference", "collections"]).optional().describe("Sidebar placement: 'daily', 'strategic', 'governance', 'reference', 'collections'"),
+  fields: z16.array(fieldSchema).max(200).optional().describe("Field definitions for create, or replacement schema for update (replaces all fields)"),
   // ENT-62
-  defaultCanonicalKey: z15.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: z16.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: z15.string().max(200).optional().describe("Default workflowStatus for new entries. Must be in validWorkflowStatuses when set (e.g. 'hypothesis' for insights)."),
+  defaultWorkflowStatus: z16.string().max(200).optional().describe("Default workflowStatus for new entries. Must be in validWorkflowStatuses when set (e.g. 'hypothesis' for insights)."),
   // ENT-65
-  validWorkflowStatuses: z15.array(z15.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: z16.array(z16.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: z15.string().max(500).optional().describe("LLM decision-tree check for this collection (3\u2013500 chars). Guides the classifier in routing entries here."),
+  classificationCheck: z16.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: z15.number().optional().describe("Classifier priority (1\u20139, lower = higher priority). Used with classificationCheck to order the decision tree."),
+  classificationPriority: z16.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: z15.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: z15.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: z16.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: z16.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: z15.string().max(50).optional().describe("For label-create/label-update: hex color, e.g. '#ef4444'."),
-  parentSlug: z15.string().max(200).optional().describe("For label-create: parent group slug for label hierarchy."),
-  isGroup: z15.boolean().optional().describe("For label-create/label-update: true if this is a group container, not a taggable label."),
-  order: z15.number().optional().describe("For label-create/label-update: sort order within its group."),
-  entryId: z15.string().max(200).optional().describe("For label-apply/label-remove: entry ID.")
+  color: z16.string().max(50).optional().describe("For label-create/label-update: hex color, e.g. '#ef4444'."),
+  parentSlug: z16.string().max(200).optional().describe("For label-create: parent group slug for label hierarchy."),
+  isGroup: z16.boolean().optional().describe("For label-create/label-update: true if this is a group container, not a taggable label."),
+  order: z16.number().optional().describe("For label-create/label-update: sort order within its group."),
+  entryId: z16.string().max(200).optional().describe("For label-apply/label-remove: entry ID.")
 });
-var collectionsListVariant = z15.object({ action: z15.literal("list") });
-var collectionsDescribeVariant = z15.object({ action: z15.literal("describe"), slug: z15.string().max(200) });
-var collectionsCreateVariant = z15.object({
-  action: z15.literal("create"),
-  slug: z15.string().max(200),
-  name: z15.string().max(500),
-  description: z15.string().max(2e4).optional(),
-  purpose: z15.string().max(2e3).optional(),
-  icon: z15.string().max(50).optional(),
-  navGroup: z15.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
-  fields: z15.array(fieldSchema).min(1),
-  defaultCanonicalKey: z15.string().max(200).optional(),
-  defaultWorkflowStatus: z15.string().max(200).optional(),
-  validWorkflowStatuses: z15.array(z15.string().max(200)).optional(),
-  classificationCheck: z15.string().max(500).optional(),
-  classificationPriority: z15.number().optional()
+var collectionsListVariant = z16.object({ action: z16.literal("list") });
+var collectionsDescribeVariant = z16.object({ action: z16.literal("describe"), slug: z16.string().max(200) });
+var collectionsCreateVariant = z16.object({
+  action: z16.literal("create"),
+  slug: z16.string().max(200),
+  name: z16.string().max(500),
+  description: z16.string().max(2e4).optional(),
+  purpose: z16.string().max(2e3).optional(),
+  icon: z16.string().max(50).optional(),
+  navGroup: z16.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
+  fields: z16.array(fieldSchema).min(1),
+  defaultCanonicalKey: z16.string().max(200).optional(),
+  defaultWorkflowStatus: z16.string().max(200).optional(),
+  validWorkflowStatuses: z16.array(z16.string().max(200)).optional(),
+  classificationCheck: z16.string().max(500).optional(),
+  classificationPriority: z16.number().optional()
 });
-var collectionsUpdateVariant = z15.object({
-  action: z15.literal("update"),
-  slug: z15.string().max(200),
-  name: z15.string().max(500).optional(),
-  description: z15.string().max(2e4).optional(),
-  purpose: z15.string().max(2e3).optional(),
-  icon: z15.string().max(50).optional(),
-  navGroup: z15.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
-  fields: z15.array(fieldSchema).optional(),
-  defaultCanonicalKey: z15.string().max(200).optional(),
-  defaultWorkflowStatus: z15.string().max(200).optional(),
-  validWorkflowStatuses: z15.array(z15.string().max(200)).optional(),
-  classificationCheck: z15.string().max(500).optional(),
-  classificationPriority: z15.number().optional(),
-  qualityCriteria: z15.array(qualityCriterionSchema).optional(),
-  usageGuidance: z15.string().max(2e4).optional()
+var collectionsUpdateVariant = z16.object({
+  action: z16.literal("update"),
+  slug: z16.string().max(200),
+  name: z16.string().max(500).optional(),
+  description: z16.string().max(2e4).optional(),
+  purpose: z16.string().max(2e3).optional(),
+  icon: z16.string().max(50).optional(),
+  navGroup: z16.enum(["daily", "strategic", "governance", "reference", "collections"]).optional(),
+  fields: z16.array(fieldSchema).optional(),
+  defaultCanonicalKey: z16.string().max(200).optional(),
+  defaultWorkflowStatus: z16.string().max(200).optional(),
+  validWorkflowStatuses: z16.array(z16.string().max(200)).optional(),
+  classificationCheck: z16.string().max(500).optional(),
+  classificationPriority: z16.number().optional(),
+  qualityCriteria: z16.array(qualityCriterionSchema).optional(),
+  usageGuidance: z16.string().max(2e4).optional()
 });
-var collectionsAuditVariant = z15.object({ action: z15.literal("audit") });
-var collectionsExportVariant = z15.object({ action: z15.literal("export") });
-var collectionsLabelListVariant = z15.object({ action: z15.literal("label-list") });
-var collectionsLabelCreateVariant = z15.object({
-  action: z15.literal("label-create"),
-  slug: z15.string().max(200),
-  name: z15.string().max(500),
-  color: z15.string().max(50).optional(),
-  description: z15.string().max(2e3).optional(),
-  parentSlug: z15.string().max(200).optional(),
-  isGroup: z15.boolean().optional(),
-  order: z15.number().optional()
+var collectionsAuditVariant = z16.object({ action: z16.literal("audit") });
+var collectionsExportVariant = z16.object({ action: z16.literal("export") });
+var collectionsLabelListVariant = z16.object({ action: z16.literal("label-list") });
+var collectionsLabelCreateVariant = z16.object({
+  action: z16.literal("label-create"),
+  slug: z16.string().max(200),
+  name: z16.string().max(500),
+  color: z16.string().max(50).optional(),
+  description: z16.string().max(2e3).optional(),
+  parentSlug: z16.string().max(200).optional(),
+  isGroup: z16.boolean().optional(),
+  order: z16.number().optional()
 });
-var collectionsLabelUpdateVariant = z15.object({
-  action: z15.literal("label-update"),
-  slug: z15.string().max(200),
-  name: z15.string().max(500).optional(),
-  color: z15.string().max(50).optional(),
-  description: z15.string().max(2e3).optional(),
-  isGroup: z15.boolean().optional(),
-  order: z15.number().optional()
+var collectionsLabelUpdateVariant = z16.object({
+  action: z16.literal("label-update"),
+  slug: z16.string().max(200),
+  name: z16.string().max(500).optional(),
+  color: z16.string().max(50).optional(),
+  description: z16.string().max(2e3).optional(),
+  isGroup: z16.boolean().optional(),
+  order: z16.number().optional()
 });
-var collectionsLabelDeleteVariant = z15.object({ action: z15.literal("label-delete"), slug: z15.string().max(200) });
-var collectionsLabelApplyVariant = z15.object({ action: z15.literal("label-apply"), slug: z15.string().max(200), entryId: z15.string().max(200) });
-var collectionsLabelRemoveVariant = z15.object({ action: z15.literal("label-remove"), slug: z15.string().max(200), entryId: z15.string().max(200) });
-var collectionsActionUnion = z15.discriminatedUnion("action", [
+var collectionsLabelDeleteVariant = z16.object({ action: z16.literal("label-delete"), slug: z16.string().max(200) });
+var collectionsLabelApplyVariant = z16.object({ action: z16.literal("label-apply"), slug: z16.string().max(200), entryId: z16.string().max(200) });
+var collectionsLabelRemoveVariant = z16.object({ action: z16.literal("label-remove"), slug: z16.string().max(200), entryId: z16.string().max(200) });
+var collectionsActionUnion = z16.discriminatedUnion("action", [
   collectionsListVariant,
   collectionsDescribeVariant,
   collectionsCreateVariant,
@@ -7660,7 +7825,7 @@ async function handleExport() {
 }
 
 // src/tools/orient.ts
-import { z as z19 } from "zod/v3";
+import { z as z20 } from "zod/v3";
 
 // src/tools/planned-work.ts
 function buildPlannedWork(allEntries) {
@@ -8661,12 +8826,12 @@ function replaceVocabTokens(body, workspaceCtx, collectionCtxMap) {
 }
 
 // src/tools/start_pb.ts
-import { z as z17 } from "zod/v3";
+import { z as z18 } from "zod/v3";
 
 // src/tools/skills.ts
-import { z as z16 } from "zod/v3";
-var skillsSchema = z16.object({
-  entryId: z16.string().min(1).describe(
+import { z as z17 } from "zod/v3";
+var skillsSchema = z17.object({
+  entryId: z17.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."
   )
 });
@@ -8679,8 +8844,8 @@ async function loadSkillBody(entryId) {
 }
 
 // src/tools/start_pb.ts
-var startPbSchema = z17.object({
-  task: z17.string().max(2e3).optional().describe(
+var startPbSchema = z18.object({
+  task: z18.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
@@ -9039,15 +9204,15 @@ ${FEEDBACK_HINT}` }],
 }
 
 // src/tools/record_activation.ts
-import { z as z18 } from "zod/v3";
-var recordActivationSchema = z18.object({
-  confirmedEntryCount: z18.number().int().min(0).describe(
+import { z as z19 } from "zod/v3";
+var recordActivationSchema = z19.object({
+  confirmedEntryCount: z19.number().int().min(0).describe(
     "Confirmed-entry count from the Phase 4 capture loop. The mutation enforces >=10."
   ),
-  entriesAcrossCollections: z18.number().int().min(0).describe(
+  entriesAcrossCollections: z19.number().int().min(0).describe(
     "Number of distinct collections those entries span. The mutation enforces >=2 (diversity soft-gate)."
   ),
-  retrievalDemoConfirmed: z18.boolean().describe(
+  retrievalDemoConfirmed: z19.boolean().describe(
     "True if the retrieval round-trip ran successfully in Phase 4. The mutation rejects false."
   )
 });
@@ -9120,65 +9285,65 @@ async function markOrientedWithSnapshotFallback(agentSessionId, coherenceSnapsho
   }
 }
 var ORIENT_ACTIONS = ["start", "task", "record-activation"];
-var orientSchema = z19.object({
-  action: z19.enum(ORIENT_ACTIONS).optional().default("task").describe(
+var orientSchema = z20.object({
+  action: z20.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: z19.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: z19.enum(["summary", "standard", "full"]).optional().describe(
+  mode: z20.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: z20.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: z19.string().max(2e3).optional().describe(
+  task: z20.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: z19.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: z20.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: z19.object({
-    changedPaths: z19.array(z19.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: z19.array(z19.string()).max(25).optional().describe("Chain entry IDs the caller has already reviewed this session, if tracked."),
-    branchName: z19.string().max(120).optional().describe("Current git branch name, if known."),
-    worktreeName: z19.string().max(120).optional().describe("Current worktree/directory name, if known.")
+  startupSignals: z20.object({
+    changedPaths: z20.array(z20.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: z20.array(z20.string()).max(25).optional().describe("Chain entry IDs the caller has already reviewed this session, if tracked."),
+    branchName: z20.string().max(120).optional().describe("Current git branch name, if known."),
+    worktreeName: z20.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: z19.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: z19.number().int().min(0).optional().describe(
+  invocationPath: z20.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: z20.number().int().min(0).optional().describe(
     "For 'record-activation': confirmed-entry count from the Phase 4 capture loop. The mutation enforces >=10."
   ),
-  entriesAcrossCollections: z19.number().int().min(0).optional().describe(
+  entriesAcrossCollections: z20.number().int().min(0).optional().describe(
     "For 'record-activation': number of distinct collections those entries span. The mutation enforces >=2 (diversity soft-gate)."
   ),
-  retrievalDemoConfirmed: z19.boolean().optional().describe(
+  retrievalDemoConfirmed: z20.boolean().optional().describe(
     "For 'record-activation': true if the retrieval round-trip ran successfully in Phase 4. The mutation rejects false."
   )
 });
-var orientStartVariant = z19.object({
-  action: z19.literal("start"),
-  task: z19.string().max(2e3).optional()
+var orientStartVariant = z20.object({
+  action: z20.literal("start"),
+  task: z20.string().max(2e3).optional()
 });
-var orientTaskVariant = z19.object({
-  action: z19.literal("task"),
-  mode: z19.enum(["full", "brief"]).optional().default("full"),
-  tier: z19.enum(["summary", "standard", "full"]).optional(),
-  task: z19.string().max(2e3).optional(),
-  scope: z19.string().max(200).optional(),
+var orientTaskVariant = z20.object({
+  action: z20.literal("task"),
+  mode: z20.enum(["full", "brief"]).optional().default("full"),
+  tier: z20.enum(["summary", "standard", "full"]).optional(),
+  task: z20.string().max(2e3).optional(),
+  scope: z20.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: z19.object({
-    changedPaths: z19.array(z19.string()).max(25).optional(),
-    reviewedArtifactRefs: z19.array(z19.string()).max(25).optional(),
-    branchName: z19.string().max(120).optional(),
-    worktreeName: z19.string().max(120).optional()
+  startupSignals: z20.object({
+    changedPaths: z20.array(z20.string()).max(25).optional(),
+    reviewedArtifactRefs: z20.array(z20.string()).max(25).optional(),
+    branchName: z20.string().max(120).optional(),
+    worktreeName: z20.string().max(120).optional()
   }).optional(),
-  invocationPath: z19.enum(["session-start", "session-close", "manual-orient", "handshake", "unknown"]).optional()
+  invocationPath: z20.enum(["session-start", "session-close", "manual-orient", "handshake", "unknown"]).optional()
 });
-var orientRecordActivationVariant = z19.object({
-  action: z19.literal("record-activation"),
-  confirmedEntryCount: z19.number().int().min(0),
-  entriesAcrossCollections: z19.number().int().min(0),
-  retrievalDemoConfirmed: z19.boolean()
+var orientRecordActivationVariant = z20.object({
+  action: z20.literal("record-activation"),
+  confirmedEntryCount: z20.number().int().min(0),
+  entriesAcrossCollections: z20.number().int().min(0),
+  retrievalDemoConfirmed: z20.boolean()
 });
-var orientActionUnion = z19.discriminatedUnion("action", [
+var orientActionUnion = z20.discriminatedUnion("action", [
   orientStartVariant,
   orientTaskVariant,
   orientRecordActivationVariant
@@ -10030,7 +10195,7 @@ async function _handleOrient({ mode = "full", tier, task, scope, startupSignals,
 }
 
 // src/tools/workflows.ts
-import { z as z20 } from "zod/v3";
+import { z as z21 } from "zod/v3";
 
 // src/workflows/descriptor.ts
 function cloneWorkflowQuestion(question) {
@@ -10870,75 +11035,75 @@ function workflowRunOutputToText(output) {
 
 // src/tools/workflows.ts
 var WORKFLOWS_ACTIONS = ["list", "start", "checkpoint", "get-run", "load-skill"];
-var jsonValueSchema = z20.lazy(
-  () => z20.union([
-    z20.string(),
-    z20.number(),
-    z20.boolean(),
-    z20.null(),
-    z20.array(jsonValueSchema),
-    z20.record(jsonValueSchema)
+var jsonValueSchema = z21.lazy(
+  () => z21.union([
+    z21.string(),
+    z21.number(),
+    z21.boolean(),
+    z21.null(),
+    z21.array(jsonValueSchema),
+    z21.record(jsonValueSchema)
   ])
 );
-var workflowRunOutputInputSchema = z20.union([
-  z20.object({
-    format: z20.literal("freetext"),
-    value: z20.string()
+var workflowRunOutputInputSchema = z21.union([
+  z21.object({
+    format: z21.literal("freetext"),
+    value: z21.string()
   }),
-  z20.object({
-    format: z20.literal("list"),
-    value: z20.array(z20.string())
+  z21.object({
+    format: z21.literal("list"),
+    value: z21.array(z21.string())
   }),
-  z20.object({
-    format: z20.literal("choice"),
-    value: z20.union([z20.string(), z20.array(z20.string())])
+  z21.object({
+    format: z21.literal("choice"),
+    value: z21.union([z21.string(), z21.array(z21.string())])
   }),
-  z20.object({
-    format: z20.literal("structured"),
+  z21.object({
+    format: z21.literal("structured"),
     value: jsonValueSchema
   })
 ]);
-var workflowsSchema = z20.object({
-  action: z20.enum(WORKFLOWS_ACTIONS).describe(
+var workflowsSchema = z21.object({
+  action: z21.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: z20.string().max(200).optional().describe("Workflow ID for start, checkpoint, or get-run, e.g. 'retro', 'implementation-review'"),
-  runId: z20.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: z20.string().max(200).optional().describe("Round ID for checkpoint, e.g. 'what-went-well'"),
-  output: z20.union([z20.string(), workflowRunOutputInputSchema]).optional().describe("The round's output \u2014 either legacy synthesized text or a typed workflow run payload."),
-  isFinal: z20.boolean().optional().describe("If true, finalize an existing durable workflow run from its terminal round and create the summary chain entry."),
-  restart: z20.boolean().optional().describe("If true, start a new durable run from the workflow's first round in the current session."),
-  summaryName: z20.string().max(500).optional().describe("Optional name for final chain entry. If omitted, the workflow summary template is used."),
-  summaryDescription: z20.string().max(2e4).optional().describe("Optional override for the final chain entry description. Defaults to the final round output text."),
-  summaryEntryId: z20.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: z20.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: z21.string().max(200).optional().describe("Workflow ID for start, checkpoint, or get-run, e.g. 'retro', 'implementation-review'"),
+  runId: z21.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: z21.string().max(200).optional().describe("Round ID for checkpoint, e.g. 'what-went-well'"),
+  output: z21.union([z21.string(), workflowRunOutputInputSchema]).optional().describe("The round's output \u2014 either legacy synthesized text or a typed workflow run payload."),
+  isFinal: z21.boolean().optional().describe("If true, finalize an existing durable workflow run from its terminal round and create the summary chain entry."),
+  restart: z21.boolean().optional().describe("If true, start a new durable run from the workflow's first round in the current session."),
+  summaryName: z21.string().max(500).optional().describe("Optional name for final chain entry. If omitted, the workflow summary template is used."),
+  summaryDescription: z21.string().max(2e4).optional().describe("Optional override for the final chain entry description. Defaults to the final round output text."),
+  summaryEntryId: z21.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: z21.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: z20.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning team (rung-2)."),
-  ownerRoleEntryId: z20.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning role (rung-2).")
+  ownerTeamEntryId: z21.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning team (rung-2)."),
+  ownerRoleEntryId: z21.string().max(200).optional().describe("For 'checkpoint' (isFinal): owning role (rung-2).")
 });
-var workflowsListVariant = z20.object({ action: z20.literal("list") });
-var workflowsGetRunVariant = z20.object({
-  action: z20.literal("get-run"),
-  runId: z20.string().max(200).optional(),
-  workflowId: z20.string().max(200).optional()
+var workflowsListVariant = z21.object({ action: z21.literal("list") });
+var workflowsGetRunVariant = z21.object({
+  action: z21.literal("get-run"),
+  runId: z21.string().max(200).optional(),
+  workflowId: z21.string().max(200).optional()
 });
-var workflowsStartVariant = z20.object({ action: z20.literal("start"), workflowId: z20.string().max(200) });
-var workflowsCheckpointVariant = z20.object({
-  action: z20.literal("checkpoint"),
-  workflowId: z20.string().max(200),
-  roundId: z20.string().max(200),
-  output: z20.union([z20.string(), workflowRunOutputInputSchema]),
-  isFinal: z20.boolean().optional(),
-  restart: z20.boolean().optional(),
-  summaryName: z20.string().max(500).optional(),
-  summaryDescription: z20.string().max(2e4).optional(),
-  summaryEntryId: z20.string().max(200).optional(),
-  runId: z20.string().max(200).optional(),
-  ownerTeamEntryId: z20.string().max(200).optional(),
-  ownerRoleEntryId: z20.string().max(200).optional()
+var workflowsStartVariant = z21.object({ action: z21.literal("start"), workflowId: z21.string().max(200) });
+var workflowsCheckpointVariant = z21.object({
+  action: z21.literal("checkpoint"),
+  workflowId: z21.string().max(200),
+  roundId: z21.string().max(200),
+  output: z21.union([z21.string(), workflowRunOutputInputSchema]),
+  isFinal: z21.boolean().optional(),
+  restart: z21.boolean().optional(),
+  summaryName: z21.string().max(500).optional(),
+  summaryDescription: z21.string().max(2e4).optional(),
+  summaryEntryId: z21.string().max(200).optional(),
+  runId: z21.string().max(200).optional(),
+  ownerTeamEntryId: z21.string().max(200).optional(),
+  ownerRoleEntryId: z21.string().max(200).optional()
 });
-var workflowsLoadSkillVariant = z20.object({ action: z20.literal("load-skill"), entryId: z20.string().max(200).min(1) });
-var workflowsActionUnion = z20.discriminatedUnion("action", [
+var workflowsLoadSkillVariant = z21.object({ action: z21.literal("load-skill"), entryId: z21.string().max(200).min(1) });
+var workflowsActionUnion = z21.discriminatedUnion("action", [
   workflowsListVariant,
   workflowsGetRunVariant,
   workflowsStartVariant,
@@ -11678,10 +11843,10 @@ function parseListOutput(output) {
 }
 
 // src/tools/quality.ts
-import { z as z22 } from "zod/v3";
+import { z as z23 } from "zod/v3";
 
 // src/tools/audit.ts
-import { z as z21 } from "zod/v3";
+import { z as z22 } from "zod/v3";
 var VOCAB_TTL_MS = 5 * 60 * 1e3;
 var MAX_VOCAB_KEYS = 100;
 var vocabCache = /* @__PURE__ */ new Map();
@@ -11711,12 +11876,12 @@ function evictVocabIfFull() {
   }
 }
 var AUDIT_ACTIONS = ["run"];
-var auditSchema = z21.object({
-  action: z21.enum(AUDIT_ACTIONS).describe(
+var auditSchema = z22.object({
+  action: z22.enum(AUDIT_ACTIONS).describe(
     "'run': run the hygiene audit for a bet entry."
   ),
-  entryId: z21.string().describe("Bet entry ID to audit, e.g. '<PREFIX>-<n>'"),
-  phase: z21.enum(["shaping", "handoff"]).default("shaping").optional().describe(
+  entryId: z22.string().describe("Bet entry ID to audit, e.g. '<PREFIX>-<n>'"),
+  phase: z22.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."
   )
 });
@@ -11909,44 +12074,44 @@ async function handleSpineCheck(story, refresh = false) {
 
 // src/tools/quality.ts
 var QUALITY_ACTIONS = ["check", "re-evaluate", "verify-chain", "audit", "spine-check"];
-var qualitySchema = z22.object({
-  action: z22.enum(QUALITY_ACTIONS).describe(
+var qualitySchema = z23.object({
+  action: z23.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`. 'spine-check': structural completeness of the purpose+vision+strategy spine \u2014 story:true also runs the on-demand one-story judgment."
   ),
-  entryId: z22.string().max(200).optional().describe("For 'check'/'re-evaluate'/'audit': entry ID, e.g. 'TEN-graph-db', '<PREFIX>-<n>'."),
-  context: z22.enum(["capture", "commit", "review"]).default("review").optional().describe("For re-evaluate: evaluation context"),
-  collection: z22.string().max(200).optional().describe("For 'verify-chain': collection slug to verify (default: glossary)."),
-  mode: z22.enum(["report", "fix"]).optional().describe("For 'verify-chain': 'report' = read-only trust report (default). 'fix' = also update drifted codeMapping statuses."),
-  phase: z22.enum(["shaping", "handoff"]).optional().describe(
+  entryId: z23.string().max(200).optional().describe("For 'check'/'re-evaluate'/'audit': entry ID, e.g. 'TEN-graph-db', '<PREFIX>-<n>'."),
+  context: z23.enum(["capture", "commit", "review"]).default("review").optional().describe("For re-evaluate: evaluation context"),
+  collection: z23.string().max(200).optional().describe("For 'verify-chain': collection slug to verify (default: glossary)."),
+  mode: z23.enum(["report", "fix"]).optional().describe("For 'verify-chain': 'report' = read-only trust report (default). 'fix' = also update drifted codeMapping statuses."),
+  phase: z23.enum(["shaping", "handoff"]).optional().describe(
     "For 'audit': 'shaping' checks shaping-phase fields only (default). 'handoff' checks all required fields including buildContract/buildSequence/exclusions/risks."
   ),
-  story: z22.boolean().optional().describe("For 'spine-check': also run the on-demand one-story LLM judgment (never scheduled; result labelled [unvalidated])."),
-  refresh: z22.boolean().optional().describe(
+  story: z23.boolean().optional().describe("For 'spine-check': also run the on-demand one-story LLM judgment (never scheduled; result labelled [unvalidated])."),
+  refresh: z23.boolean().optional().describe(
     "For 'spine-check': force a new run even if a fresh verdict already exists. Default false \u2014 a plain call NEVER re-triggers work just to read the last result; it auto-schedules only when no run is already in flight AND the stored verdict is absent/stale/missing the requested story pass."
   )
 });
-var qualityCheckVariant = z22.object({ action: z22.literal("check"), entryId: z22.string().max(200) });
-var qualityReEvaluateVariant = z22.object({
-  action: z22.literal("re-evaluate"),
-  entryId: z22.string().max(200),
-  context: z22.enum(["capture", "commit", "review"]).optional().default("review")
+var qualityCheckVariant = z23.object({ action: z23.literal("check"), entryId: z23.string().max(200) });
+var qualityReEvaluateVariant = z23.object({
+  action: z23.literal("re-evaluate"),
+  entryId: z23.string().max(200),
+  context: z23.enum(["capture", "commit", "review"]).optional().default("review")
 });
-var qualityVerifyChainVariant = z22.object({
-  action: z22.literal("verify-chain"),
-  collection: z22.string().max(200).optional().default("glossary"),
-  mode: z22.enum(["report", "fix"]).optional().default("report")
+var qualityVerifyChainVariant = z23.object({
+  action: z23.literal("verify-chain"),
+  collection: z23.string().max(200).optional().default("glossary"),
+  mode: z23.enum(["report", "fix"]).optional().default("report")
 });
-var qualityAuditVariant = z22.object({
-  action: z22.literal("audit"),
-  entryId: z22.string().max(200),
-  phase: z22.enum(["shaping", "handoff"]).optional().default("shaping")
+var qualityAuditVariant = z23.object({
+  action: z23.literal("audit"),
+  entryId: z23.string().max(200),
+  phase: z23.enum(["shaping", "handoff"]).optional().default("shaping")
 });
-var qualitySpineCheckVariant = z22.object({
-  action: z22.literal("spine-check"),
-  story: z22.boolean().optional().default(false),
-  refresh: z22.boolean().optional().default(false)
+var qualitySpineCheckVariant = z23.object({
+  action: z23.literal("spine-check"),
+  story: z23.boolean().optional().default(false),
+  refresh: z23.boolean().optional().default(false)
 });
-var qualityActionUnion = z22.discriminatedUnion("action", [
+var qualityActionUnion = z23.discriminatedUnion("action", [
   qualityCheckVariant,
   qualityReEvaluateVariant,
   qualityVerifyChainVariant,
@@ -11960,34 +12125,34 @@ var QUALITY_ACTION_SPECS = {
   audit: { params: ["entryId", "phase"], description: "entryId is required." },
   "spine-check": { params: ["story", "refresh"], description: "All params optional; story and refresh default to false \u2014 a plain call never re-triggers work, it just reads back the latest verdict (auto-refreshing only when stale/absent)." }
 };
-var qualityCheckOutputSchema = z22.object({
-  entryId: z22.string(),
+var qualityCheckOutputSchema = z23.object({
+  entryId: z23.string(),
   /** WP-480 S1: false = the ID does not resolve to an entry (typo/deleted) — distinct from "no verdict yet". */
-  entryFound: z22.boolean().optional(),
-  hasVerdict: z22.boolean(),
+  entryFound: z23.boolean().optional(),
+  hasVerdict: z23.boolean(),
   /** WP-480 S1: the verdict was judged against content the entry no longer has — re-evaluate for a current one. */
-  stale: z22.boolean().optional(),
-  tier: z22.string().optional(),
-  passed: z22.boolean().optional(),
-  criteria: z22.array(z22.object({
-    id: z22.string(),
-    passed: z22.boolean(),
-    hint: z22.string().optional()
+  stale: z23.boolean().optional(),
+  tier: z23.string().optional(),
+  passed: z23.boolean().optional(),
+  criteria: z23.array(z23.object({
+    id: z23.string(),
+    passed: z23.boolean(),
+    hint: z23.string().optional()
   }))
 });
-var qualityReevaluateOutputSchema = z22.object({
-  entryId: z22.string(),
-  context: z22.string(),
-  score: z22.number(),
-  maxScore: z22.number(),
-  improved: z22.boolean()
+var qualityReevaluateOutputSchema = z23.object({
+  entryId: z23.string(),
+  context: z23.string(),
+  score: z23.number(),
+  maxScore: z23.number(),
+  improved: z23.boolean()
 });
-var qualitySpineCheckOutputSchema = z22.object({
-  hasVerdict: z22.boolean(),
-  noSpineEntries: z22.boolean().optional(),
-  structuralPassed: z22.boolean().optional(),
-  storyPassed: z22.boolean().nullable().optional(),
-  stale: z22.boolean().optional()
+var qualitySpineCheckOutputSchema = z23.object({
+  hasVerdict: z23.boolean(),
+  noSpineEntries: z23.boolean().optional(),
+  structuralPassed: z23.boolean().optional(),
+  storyPassed: z23.boolean().nullable().optional(),
+  stale: z23.boolean().optional()
 });
 function registerQualityTools(server) {
   const qualityHandlers = {
@@ -12169,10 +12334,10 @@ async function handleReEvaluate(entryId, context) {
 }
 
 // src/tools/session.ts
-import { z as z25 } from "zod/v3";
+import { z as z26 } from "zod/v3";
 
 // src/tools/wrapup.ts
-import { z as z23 } from "zod/v3";
+import { z as z24 } from "zod/v3";
 
 // src/lib/compose-wrapup-view.ts
 function toComposed(e) {
@@ -12625,8 +12790,8 @@ async function runWrapupCommitAll(data, cachedSuggestions) {
     overflowUnscanned
   };
 }
-var wrapupSchema = z23.object({
-  action: z23.enum(["review", "commit-all"]).optional().describe(
+var wrapupSchema = z24.object({
+  action: z24.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."
   )
 });
@@ -12727,26 +12892,26 @@ ${text}` : text;
 }
 
 // src/tools/facilitate.ts
-import { z as z24 } from "zod/v3";
+import { z as z25 } from "zod/v3";
 var FACILITATE_ACTIONS = ["resume", "commit-constellation"];
-var coherencyAcknowledgementSchema = 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 (e.g. the strategic spine entry)."),
-  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 coherencyAcknowledgementSchema = z25.object({
+  response: z25.string().max(200).describe("Acknowledgement response per offender: 'linked' | 'accepted-fix' | 'diverged'."),
+  entryId: z25.string().max(200).optional().describe("Entry the acknowledgement links to (e.g. the strategic spine entry)."),
+  reason: z25.string().max(2e3).optional().describe("Free-text justification, required for a 'diverged' response."),
+  subjectEntryId: z25.string().max(200).optional().describe("The refused entry this acknowledgement answers.")
 });
-var facilitateSchema = z24.object({
-  action: z24.enum(FACILITATE_ACTIONS).describe(
+var facilitateSchema = z25.object({
+  action: z25.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: z24.string().max(200).optional().describe("Bet entry ID. Required for both actions."),
-  operationId: z24.string().max(200).optional().describe("Optional idempotency key for commit-constellation retries."),
+  betEntryId: z25.string().max(200).optional().describe("Bet entry ID. Required for both actions."),
+  operationId: z25.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: z24.array(coherencyAcknowledgementSchema).max(20).optional().describe(
+  coherencyAcknowledgements: z25.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: z24.string().max(2e3).optional().describe(
+  steeringOverrideReason: z25.string().max(2e3).optional().describe(
     "Typed override reason (>= 12 chars) to push a constellation past a coherency hold instead of acknowledging."
   )
 });
@@ -13017,33 +13182,33 @@ var SESSION_ACTIONS = [
   "resume",
   "commit-constellation"
 ];
-var coherencyAcknowledgementFlatSchema2 = z25.object({
-  response: z25.string().max(200).describe("Acknowledgement response per offender: 'linked' | 'accepted-fix' | 'diverged'."),
-  entryId: z25.string().max(200).optional().describe("Entry the acknowledgement links to."),
-  reason: z25.string().max(2e3).optional().describe("Free-text justification, required for a 'diverged' response."),
-  subjectEntryId: z25.string().max(200).optional().describe("The refused entry this acknowledgement answers.")
+var coherencyAcknowledgementFlatSchema2 = z26.object({
+  response: z26.string().max(200).describe("Acknowledgement response per offender: 'linked' | 'accepted-fix' | 'diverged'."),
+  entryId: z26.string().max(200).optional().describe("Entry the acknowledgement links to."),
+  reason: z26.string().max(2e3).optional().describe("Free-text justification, required for a 'diverged' response."),
+  subjectEntryId: z26.string().max(200).optional().describe("The refused entry this acknowledgement answers.")
 });
-var sessionSchema = z25.object({
-  action: z25.enum(SESSION_ACTIONS).describe(
+var sessionSchema = z26.object({
+  action: z26.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: z25.string().max(200).optional().describe("For 'resume'/'commit-constellation': bet entry ID. Required for both."),
-  operationId: z25.string().max(200).optional().describe("For 'commit-constellation': optional idempotency key for retries."),
-  coherencyAcknowledgements: z25.array(coherencyAcknowledgementFlatSchema2).max(20).optional().describe(
+  betEntryId: z26.string().max(200).optional().describe("For 'resume'/'commit-constellation': bet entry ID. Required for both."),
+  operationId: z26.string().max(200).optional().describe("For 'commit-constellation': optional idempotency key for retries."),
+  coherencyAcknowledgements: z26.array(coherencyAcknowledgementFlatSchema2).max(20).optional().describe(
     "For 'commit-constellation': per-offender acknowledgements to retry a constellation held under standard/strict coherency mode."
   ),
-  steeringOverrideReason: z25.string().max(2e3).optional().describe(
+  steeringOverrideReason: z26.string().max(2e3).optional().describe(
     "For 'commit-constellation': typed override reason (>= 12 chars) to push past a coherency hold instead of acknowledging."
   )
 });
-var sessionStartVariant = z25.object({ action: z25.literal("start") });
-var sessionCloseVariant = z25.object({ action: z25.literal("close") });
-var sessionStatusVariant = z25.object({ action: z25.literal("status") });
-var sessionWrapupReviewVariant = z25.object({ action: z25.literal("wrapup-review") });
-var sessionWrapupCommitVariant = z25.object({ action: z25.literal("wrapup-commit") });
-var sessionResumeVariant = facilitateSchema.omit({ action: true }).extend({ action: z25.literal("resume") });
-var sessionCommitConstellationVariant = facilitateSchema.omit({ action: true }).extend({ action: z25.literal("commit-constellation") });
-var sessionActionUnion = z25.discriminatedUnion("action", [
+var sessionStartVariant = z26.object({ action: z26.literal("start") });
+var sessionCloseVariant = z26.object({ action: z26.literal("close") });
+var sessionStatusVariant = z26.object({ action: z26.literal("status") });
+var sessionWrapupReviewVariant = z26.object({ action: z26.literal("wrapup-review") });
+var sessionWrapupCommitVariant = z26.object({ action: z26.literal("wrapup-commit") });
+var sessionResumeVariant = facilitateSchema.omit({ action: true }).extend({ action: z26.literal("resume") });
+var sessionCommitConstellationVariant = facilitateSchema.omit({ action: true }).extend({ action: z26.literal("commit-constellation") });
+var sessionActionUnion = z26.discriminatedUnion("action", [
   sessionStartVariant,
   sessionCloseVariant,
   sessionStatusVariant,
@@ -13288,7 +13453,7 @@ async function handleStatus() {
 }
 
 // src/tools/gitchain.ts
-import { z as z26 } from "zod/v3";
+import { z as z27 } from "zod/v3";
 
 // src/lib/versionDisplay.ts
 function toVersionDisplay(version) {
@@ -13297,51 +13462,51 @@ function toVersionDisplay(version) {
 }
 
 // src/tools/gitchain.ts
-var chainSchema = z26.object({
-  action: z26.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
-  chainEntryId: z26.string().max(200).optional().describe("Chain entry ID (required for get/edit)"),
-  title: z26.string().max(500).optional().describe("Process title (required for create)"),
-  chainTypeId: z26.string().max(200).optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
-  description: z26.string().max(2e4).optional().describe("Description (for create)"),
-  linkId: z26.string().max(200).optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
-  content: z26.string().max(5e4).optional().describe("New content for the link (for edit action)"),
-  status: z26.string().max(200).optional().describe("Filter by status for list: 'draft' or 'active'"),
-  author: z26.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'."),
+var chainSchema = z27.object({
+  action: z27.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
+  chainEntryId: z27.string().max(200).optional().describe("Chain entry ID (required for get/edit)"),
+  title: z27.string().max(500).optional().describe("Process title (required for create)"),
+  chainTypeId: z27.string().max(200).optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
+  description: z27.string().max(2e4).optional().describe("Description (for create)"),
+  linkId: z27.string().max(200).optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
+  content: z27.string().max(5e4).optional().describe("New content for the link (for edit action)"),
+  status: z27.string().max(200).optional().describe("Filter by status for list: 'draft' or 'active'"),
+  author: z27.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: z26.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
-  ownerRoleEntryId: z26.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
+  ownerTeamEntryId: z27.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
+  ownerRoleEntryId: z27.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
 });
-var chainVersionSchema = z26.object({
-  action: z26.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
-  chainEntryId: z26.string().max(200).describe("The chain's entry ID"),
-  commitMessage: z26.string().max(2e3).optional().describe("Commit message (required for commit). Convention: type(link): description"),
-  versionA: z26.number().optional().describe("Earlier version for diff"),
-  versionB: z26.number().optional().describe("Later version for diff"),
-  toVersion: z26.number().optional().describe("Version number to revert to"),
-  author: z26.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+var chainVersionSchema = z27.object({
+  action: z27.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
+  chainEntryId: z27.string().max(200).describe("The chain's entry ID"),
+  commitMessage: z27.string().max(2e3).optional().describe("Commit message (required for commit). Convention: type(link): description"),
+  versionA: z27.number().optional().describe("Earlier version for diff"),
+  versionB: z27.number().optional().describe("Later version for diff"),
+  toVersion: z27.number().optional().describe("Version number to revert to"),
+  author: z27.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainBranchSchema = z26.object({
-  action: z26.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
-  chainEntryId: z26.string().max(200).describe("The chain's entry ID"),
-  branchName: z26.string().max(200).optional().describe("Branch name (required for merge/conflicts, optional for create)"),
-  strategy: z26.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
-  author: z26.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+var chainBranchSchema = z27.object({
+  action: z27.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
+  chainEntryId: z27.string().max(200).describe("The chain's entry ID"),
+  branchName: z27.string().max(200).optional().describe("Branch name (required for merge/conflicts, optional for create)"),
+  strategy: z27.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
+  author: z27.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainReviewSchema = z26.object({
-  action: z26.enum(["gate", "comment", "resolve-comment", "list-comments"]).describe("Action: run coherence gate, add a comment, resolve a comment, or list comments"),
+var chainReviewSchema = z27.object({
+  action: z27.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: z26.string().max(200).optional().describe("The chain's entry ID. Required for every action except 'resolve-comment'."),
-  commitMessage: z26.string().max(2e3).optional().describe("Commit message to lint (for gate action)"),
-  versionNumber: z26.number().optional().describe("Version to comment on or list comments for"),
-  linkId: z26.string().max(200).optional().describe("Link this comment targets (optional for comment)"),
-  body: z26.string().max(2e4).optional().describe("Comment text (required for comment action)"),
-  commentId: z26.string().max(200).optional().describe("Comment ID (required for resolve-comment)"),
-  author: z26.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+  chainEntryId: z27.string().max(200).optional().describe("The chain's entry ID. Required for every action except 'resolve-comment'."),
+  commitMessage: z27.string().max(2e3).optional().describe("Commit message to lint (for gate action)"),
+  versionNumber: z27.number().optional().describe("Version to comment on or list comments for"),
+  linkId: z27.string().max(200).optional().describe("Link this comment targets (optional for comment)"),
+  body: z27.string().max(2e4).optional().describe("Comment text (required for comment action)"),
+  commentId: z27.string().max(200).optional().describe("Comment ID (required for resolve-comment)"),
+  author: z27.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
 function linkSummary(links) {
   return Object.entries(links).map(([id, content]) => {
@@ -13846,57 +14011,57 @@ var CHAIN_REVIEW_ACTIONS = [
   "branch.merge",
   "branch.conflicts"
 ];
-var chainCompoundSchema = z26.object({
-  action: z26.enum(CHAIN_ACTIONS).describe(
+var chainCompoundSchema = z27.object({
+  action: z27.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: z26.string().max(200).optional().describe("Chain entry ID. Required for get/edit and all version.* actions."),
-  title: z26.string().max(500).optional().describe("For 'create': process title (required)."),
-  chainTypeId: z26.string().max(200).optional().default("strategy-coherence").describe("For 'create'/'list': process template slug."),
-  description: z26.string().max(2e4).optional().describe("For 'create': description."),
-  linkId: z26.string().max(200).optional().describe("For 'edit': link to edit (required)."),
-  content: z26.string().max(5e4).optional().describe("For 'edit': new content for the link (required)."),
-  status: z26.string().max(200).optional().describe("For 'list': filter by status."),
-  author: z26.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'."),
-  commitMessage: z26.string().max(2e3).optional().describe("For 'version.commit': commit message (required)."),
-  versionA: z26.number().optional().describe("For 'version.diff': earlier version (required)."),
-  versionB: z26.number().optional().describe("For 'version.diff': later version (required)."),
-  toVersion: z26.number().optional().describe("For 'version.revert': version number to revert to (required)."),
+  chainEntryId: z27.string().max(200).optional().describe("Chain entry ID. Required for get/edit and all version.* actions."),
+  title: z27.string().max(500).optional().describe("For 'create': process title (required)."),
+  chainTypeId: z27.string().max(200).optional().default("strategy-coherence").describe("For 'create'/'list': process template slug."),
+  description: z27.string().max(2e4).optional().describe("For 'create': description."),
+  linkId: z27.string().max(200).optional().describe("For 'edit': link to edit (required)."),
+  content: z27.string().max(5e4).optional().describe("For 'edit': new content for the link (required)."),
+  status: z27.string().max(200).optional().describe("For 'list': filter by status."),
+  author: z27.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'."),
+  commitMessage: z27.string().max(2e3).optional().describe("For 'version.commit': commit message (required)."),
+  versionA: z27.number().optional().describe("For 'version.diff': earlier version (required)."),
+  versionB: z27.number().optional().describe("For 'version.diff': later version (required)."),
+  toVersion: z27.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: z26.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
-  ownerRoleEntryId: z26.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
+  ownerTeamEntryId: z27.string().max(200).optional().describe("For 'create': owning team (rung-2 workspaces)."),
+  ownerRoleEntryId: z27.string().max(200).optional().describe("For 'create': owning role (rung-2 workspaces).")
 });
-var chainReviewCompoundSchema = z26.object({
-  action: z26.enum(CHAIN_REVIEW_ACTIONS).describe(
+var chainReviewCompoundSchema = z27.object({
+  action: z27.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: z26.string().max(200).optional().describe("Chain entry ID. Required for every action except 'resolve-comment'."),
-  commitMessage: z26.string().max(2e3).optional().describe("For 'gate': commit message to lint."),
-  versionNumber: z26.number().optional().describe("For 'comment'/'list-comments': version to comment on or list comments for."),
-  linkId: z26.string().max(200).optional().describe("For 'comment': optional link this comment targets."),
-  body: z26.string().max(2e4).optional().describe("For 'comment': comment text (required)."),
-  commentId: z26.string().max(200).optional().describe("For 'resolve-comment': comment ID (required)."),
-  branchName: z26.string().max(200).optional().describe("For 'branch.merge'/'branch.conflicts': required. For 'branch.create': optional."),
-  strategy: z26.enum(["merge_commit", "squash"]).optional().describe("For 'branch.merge': merge strategy. Default 'merge_commit'."),
-  author: z26.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
+  chainEntryId: z27.string().max(200).optional().describe("Chain entry ID. Required for every action except 'resolve-comment'."),
+  commitMessage: z27.string().max(2e3).optional().describe("For 'gate': commit message to lint."),
+  versionNumber: z27.number().optional().describe("For 'comment'/'list-comments': version to comment on or list comments for."),
+  linkId: z27.string().max(200).optional().describe("For 'comment': optional link this comment targets."),
+  body: z27.string().max(2e4).optional().describe("For 'comment': comment text (required)."),
+  commentId: z27.string().max(200).optional().describe("For 'resolve-comment': comment ID (required)."),
+  branchName: z27.string().max(200).optional().describe("For 'branch.merge'/'branch.conflicts': required. For 'branch.create': optional."),
+  strategy: z27.enum(["merge_commit", "squash"]).optional().describe("For 'branch.merge': merge strategy. Default 'merge_commit'."),
+  author: z27.string().max(200).optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainCreateVariant = chainSchema.omit({ action: true }).extend({ action: z26.literal("create") });
-var chainGetVariant = z26.object({ action: z26.literal("get"), chainEntryId: z26.string().max(200) });
-var chainListVariant = z26.object({ action: z26.literal("list"), chainTypeId: z26.string().max(200).optional(), status: z26.string().max(200).optional() });
-var chainEditVariant = z26.object({
-  action: z26.literal("edit"),
-  chainEntryId: z26.string().max(200),
-  linkId: z26.string().max(200),
-  content: z26.string().max(5e4),
-  author: z26.string().max(200).optional()
+var chainCreateVariant = chainSchema.omit({ action: true }).extend({ action: z27.literal("create") });
+var chainGetVariant = z27.object({ action: z27.literal("get"), chainEntryId: z27.string().max(200) });
+var chainListVariant = z27.object({ action: z27.literal("list"), chainTypeId: z27.string().max(200).optional(), status: z27.string().max(200).optional() });
+var chainEditVariant = z27.object({
+  action: z27.literal("edit"),
+  chainEntryId: z27.string().max(200),
+  linkId: z27.string().max(200),
+  content: z27.string().max(5e4),
+  author: z27.string().max(200).optional()
 });
 var versionBase = chainVersionSchema.omit({ action: true });
-var chainVersionCommitVariant = versionBase.extend({ action: z26.literal("version.commit"), commitMessage: z26.string().max(2e3) });
-var chainVersionListVariant = versionBase.extend({ action: z26.literal("version.list") });
-var chainVersionDiffVariant = versionBase.extend({ action: z26.literal("version.diff"), versionA: z26.number(), versionB: z26.number() });
-var chainVersionRevertVariant = versionBase.extend({ action: z26.literal("version.revert"), toVersion: z26.number() });
-var chainVersionHistoryVariant = versionBase.extend({ action: z26.literal("version.history") });
-var chainActionUnion = z26.discriminatedUnion("action", [
+var chainVersionCommitVariant = versionBase.extend({ action: z27.literal("version.commit"), commitMessage: z27.string().max(2e3) });
+var chainVersionListVariant = versionBase.extend({ action: z27.literal("version.list") });
+var chainVersionDiffVariant = versionBase.extend({ action: z27.literal("version.diff"), versionA: z27.number(), versionB: z27.number() });
+var chainVersionRevertVariant = versionBase.extend({ action: z27.literal("version.revert"), toVersion: z27.number() });
+var chainVersionHistoryVariant = versionBase.extend({ action: z27.literal("version.history") });
+var chainActionUnion = z27.discriminatedUnion("action", [
   chainCreateVariant,
   chainGetVariant,
   chainListVariant,
@@ -13908,16 +14073,16 @@ var chainActionUnion = z26.discriminatedUnion("action", [
   chainVersionHistoryVariant
 ]);
 var reviewBase = chainReviewSchema.omit({ action: true });
-var chainReviewGateVariant = reviewBase.extend({ action: z26.literal("gate"), chainEntryId: z26.string().max(200) });
-var chainReviewCommentVariant = reviewBase.extend({ action: z26.literal("comment"), chainEntryId: z26.string().max(200), versionNumber: z26.number(), body: z26.string().max(2e4) });
-var chainReviewResolveCommentVariant = reviewBase.extend({ action: z26.literal("resolve-comment"), commentId: z26.string().max(200) });
-var chainReviewListCommentsVariant = reviewBase.extend({ action: z26.literal("list-comments"), chainEntryId: z26.string().max(200) });
+var chainReviewGateVariant = reviewBase.extend({ action: z27.literal("gate"), chainEntryId: z27.string().max(200) });
+var chainReviewCommentVariant = reviewBase.extend({ action: z27.literal("comment"), chainEntryId: z27.string().max(200), versionNumber: z27.number(), body: z27.string().max(2e4) });
+var chainReviewResolveCommentVariant = reviewBase.extend({ action: z27.literal("resolve-comment"), commentId: z27.string().max(200) });
+var chainReviewListCommentsVariant = reviewBase.extend({ action: z27.literal("list-comments"), chainEntryId: z27.string().max(200) });
 var branchBase = chainBranchSchema.omit({ action: true });
-var chainBranchCreateVariant = branchBase.extend({ action: z26.literal("branch.create") });
-var chainBranchListVariant = branchBase.extend({ action: z26.literal("branch.list") });
-var chainBranchMergeVariant = branchBase.extend({ action: z26.literal("branch.merge"), branchName: z26.string().max(200) });
-var chainBranchConflictsVariant = branchBase.extend({ action: z26.literal("branch.conflicts"), branchName: z26.string().max(200) });
-var chainReviewActionUnion = z26.discriminatedUnion("action", [
+var chainBranchCreateVariant = branchBase.extend({ action: z27.literal("branch.create") });
+var chainBranchListVariant = branchBase.extend({ action: z27.literal("branch.list") });
+var chainBranchMergeVariant = branchBase.extend({ action: z27.literal("branch.merge"), branchName: z27.string().max(200) });
+var chainBranchConflictsVariant = branchBase.extend({ action: z27.literal("branch.conflicts"), branchName: z27.string().max(200) });
+var chainReviewActionUnion = z27.discriminatedUnion("action", [
   chainReviewGateVariant,
   chainReviewCommentVariant,
   chainReviewResolveCommentVariant,
@@ -14009,44 +14174,44 @@ function registerGitChainTools(server) {
 }
 
 // src/tools/maps.ts
-import { z as z27 } from "zod/v3";
-var createAudienceMapSetSchema = z27.object({
-  audienceEntryId: z27.string().max(200).describe("Entry ID of the audience (e.g. STR-fb7hje)"),
+import { z as z28 } from "zod/v3";
+var createAudienceMapSetSchema = z28.object({
+  audienceEntryId: z28.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: z27.string().max(200).optional().describe("Team entry ID/ref to own the created maps (required once the workspace is on rung 2)"),
-  ownerRoleEntryId: z27.string().max(200).optional().describe("Role entry ID/ref to own the created maps (required once the workspace is on rung 2)")
+  ownerTeamEntryId: z28.string().max(200).optional().describe("Team entry ID/ref to own the created maps (required once the workspace is on rung 2)"),
+  ownerRoleEntryId: z28.string().max(200).optional().describe("Role entry ID/ref to own the created maps (required once the workspace is on rung 2)")
 });
-var mapSchema = z27.object({
-  action: z27.enum(["create", "get", "list"]).describe("Action: create a map, get map details, or list all maps"),
-  mapEntryId: z27.string().max(200).optional().describe("Map entry ID (for get)"),
-  title: z27.string().max(500).optional().describe("Map title (for create)"),
-  templateId: z27.string().max(200).optional().default("lean-canvas").describe("Template slug for create: 'lean-canvas' or any composed template"),
-  description: z27.string().max(2e4).optional().describe("Description (for create)"),
-  slotIds: z27.array(z27.string().max(200)).max(200).optional().describe("Slot IDs to initialize (for create; auto-populated from template if omitted)"),
-  status: z27.string().max(200).optional().describe("Filter by status for list"),
+var mapSchema = z28.object({
+  action: z28.enum(["create", "get", "list"]).describe("Action: create a map, get map details, or list all maps"),
+  mapEntryId: z28.string().max(200).optional().describe("Map entry ID (for get)"),
+  title: z28.string().max(500).optional().describe("Map title (for create)"),
+  templateId: z28.string().max(200).optional().default("lean-canvas").describe("Template slug for create: 'lean-canvas' or any composed template"),
+  description: z28.string().max(2e4).optional().describe("Description (for create)"),
+  slotIds: z28.array(z28.string().max(200)).max(200).optional().describe("Slot IDs to initialize (for create; auto-populated from template if omitted)"),
+  status: z28.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: z27.string().max(200).optional().describe("Team entry ID/ref to own the created map (required once the workspace is on rung 2)"),
-  ownerRoleEntryId: z27.string().max(200).optional().describe("Role entry ID/ref to own the created map (required once the workspace is on rung 2)")
+  ownerTeamEntryId: z28.string().max(200).optional().describe("Team entry ID/ref to own the created map (required once the workspace is on rung 2)"),
+  ownerRoleEntryId: z28.string().max(200).optional().describe("Role entry ID/ref to own the created map (required once the workspace is on rung 2)")
 });
-var mapSlotSchema = z27.object({
-  action: z27.enum(["add", "remove", "replace", "list"]).describe("Action: add/remove/replace an ingredient in a slot, or list slot contents"),
-  mapEntryId: z27.string().max(200).describe("Map entry ID"),
-  slotId: z27.string().max(200).optional().describe("Slot ID (e.g. 'problem', 'customer-segments')"),
-  ingredientEntryId: z27.string().max(200).optional().describe("Ingredient entry ID to add/remove"),
-  newIngredientEntryId: z27.string().max(200).optional().describe("New ingredient entry ID (for replace)"),
-  label: z27.string().max(500).optional().describe("Display label override"),
-  author: z27.string().max(200).optional().describe("Who is performing the action")
+var mapSlotSchema = z28.object({
+  action: z28.enum(["add", "remove", "replace", "list"]).describe("Action: add/remove/replace an ingredient in a slot, or list slot contents"),
+  mapEntryId: z28.string().max(200).describe("Map entry ID"),
+  slotId: z28.string().max(200).optional().describe("Slot ID (e.g. 'problem', 'customer-segments')"),
+  ingredientEntryId: z28.string().max(200).optional().describe("Ingredient entry ID to add/remove"),
+  newIngredientEntryId: z28.string().max(200).optional().describe("New ingredient entry ID (for replace)"),
+  label: z28.string().max(500).optional().describe("Display label override"),
+  author: z28.string().max(200).optional().describe("Who is performing the action")
 });
-var mapVersionSchema = z27.object({
-  action: z27.enum(["commit", "list", "history"]).describe("Action: commit the map, list commits, or view commit history"),
-  mapEntryId: z27.string().max(200).describe("Map entry ID"),
-  commitMessage: z27.string().max(2e3).optional().describe("Commit message (for commit action)"),
-  author: z27.string().max(200).optional().describe("Who is committing")
+var mapVersionSchema = z28.object({
+  action: z28.enum(["commit", "list", "history"]).describe("Action: commit the map, list commits, or view commit history"),
+  mapEntryId: z28.string().max(200).describe("Map entry ID"),
+  commitMessage: z28.string().max(2e3).optional().describe("Commit message (for commit action)"),
+  author: z28.string().max(200).optional().describe("Who is committing")
 });
-var mapSuggestSchema = z27.object({
-  mapEntryId: z27.string().max(200).describe("Map entry ID to suggest ingredients for"),
-  slotId: z27.string().max(200).optional().describe("Specific slot to find ingredients for (or all empty slots)"),
-  query: z27.string().max(500).optional().describe("Optional search query to narrow ingredient suggestions")
+var mapSuggestSchema = z28.object({
+  mapEntryId: z28.string().max(200).describe("Map entry ID to suggest ingredients for"),
+  slotId: z28.string().max(200).optional().describe("Specific slot to find ingredients for (or all empty slots)"),
+  query: z28.string().max(500).optional().describe("Optional search query to narrow ingredient suggestions")
 });
 function slotSummary(slots) {
   return Object.entries(slots).map(([id, refs]) => {
@@ -14426,43 +14591,43 @@ var MAP_ACTIONS = [
   "suggest",
   "create-audience-set"
 ];
-var mapCompoundSchema = z27.object({
-  action: z27.enum(MAP_ACTIONS).describe(
+var mapCompoundSchema = z28.object({
+  action: z28.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: z27.string().max(200).optional().describe("Map entry ID. Required for get and all slot.*/version.*/suggest actions."),
-  title: z27.string().max(500).optional().describe("For 'create': map title (required)."),
-  templateId: z27.string().max(200).optional().default("lean-canvas").describe("For 'create': template slug."),
-  description: z27.string().max(2e4).optional().describe("For 'create': description."),
-  slotIds: z27.array(z27.string().max(200)).max(200).optional().describe("For 'create': slot IDs to initialize."),
-  status: z27.string().max(200).optional().describe("For 'list': filter by status."),
-  slotId: z27.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': slot ID (required). For 'suggest': specific slot (optional)."),
-  ingredientEntryId: z27.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': ingredient entry ID to add/remove (required)."),
-  newIngredientEntryId: z27.string().max(200).optional().describe("For 'slot.replace': new ingredient entry ID (required)."),
-  label: z27.string().max(500).optional().describe("For 'slot.add'/'slot.replace': display label override."),
-  author: z27.string().max(200).optional().describe("Who is performing the action."),
-  commitMessage: z27.string().max(2e3).optional().describe("For 'version.commit': commit message."),
-  query: z27.string().max(500).optional().describe("For 'suggest': search query to narrow ingredient suggestions."),
-  audienceEntryId: z27.string().max(200).optional().describe("For 'create-audience-set': audience entry ID (required)."),
+  mapEntryId: z28.string().max(200).optional().describe("Map entry ID. Required for get and all slot.*/version.*/suggest actions."),
+  title: z28.string().max(500).optional().describe("For 'create': map title (required)."),
+  templateId: z28.string().max(200).optional().default("lean-canvas").describe("For 'create': template slug."),
+  description: z28.string().max(2e4).optional().describe("For 'create': description."),
+  slotIds: z28.array(z28.string().max(200)).max(200).optional().describe("For 'create': slot IDs to initialize."),
+  status: z28.string().max(200).optional().describe("For 'list': filter by status."),
+  slotId: z28.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': slot ID (required). For 'suggest': specific slot (optional)."),
+  ingredientEntryId: z28.string().max(200).optional().describe("For 'slot.add'/'slot.remove'/'slot.replace': ingredient entry ID to add/remove (required)."),
+  newIngredientEntryId: z28.string().max(200).optional().describe("For 'slot.replace': new ingredient entry ID (required)."),
+  label: z28.string().max(500).optional().describe("For 'slot.add'/'slot.replace': display label override."),
+  author: z28.string().max(200).optional().describe("Who is performing the action."),
+  commitMessage: z28.string().max(2e3).optional().describe("For 'version.commit': commit message."),
+  query: z28.string().max(500).optional().describe("For 'suggest': search query to narrow ingredient suggestions."),
+  audienceEntryId: z28.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: z27.string().max(200).optional().describe("For 'create'/'create-audience-set': owning team (rung-2 workspaces)."),
-  ownerRoleEntryId: z27.string().max(200).optional().describe("For 'create'/'create-audience-set': owning role (rung-2 workspaces).")
+  ownerTeamEntryId: z28.string().max(200).optional().describe("For 'create'/'create-audience-set': owning team (rung-2 workspaces)."),
+  ownerRoleEntryId: z28.string().max(200).optional().describe("For 'create'/'create-audience-set': owning role (rung-2 workspaces).")
 });
-var mapCreateVariant = mapSchema.omit({ action: true }).extend({ action: z27.literal("create") });
-var mapGetVariant = z27.object({ action: z27.literal("get"), mapEntryId: z27.string().max(200) });
-var mapListVariant = z27.object({ action: z27.literal("list"), templateId: z27.string().max(200).optional(), status: z27.string().max(200).optional() });
+var mapCreateVariant = mapSchema.omit({ action: true }).extend({ action: z28.literal("create") });
+var mapGetVariant = z28.object({ action: z28.literal("get"), mapEntryId: z28.string().max(200) });
+var mapListVariant = z28.object({ action: z28.literal("list"), templateId: z28.string().max(200).optional(), status: z28.string().max(200).optional() });
 var slotBase = mapSlotSchema.omit({ action: true });
-var mapSlotAddVariant = slotBase.extend({ action: z27.literal("slot.add"), slotId: z27.string().max(200), ingredientEntryId: z27.string().max(200) });
-var mapSlotRemoveVariant = slotBase.extend({ action: z27.literal("slot.remove"), slotId: z27.string().max(200), ingredientEntryId: z27.string().max(200) });
-var mapSlotReplaceVariant = slotBase.extend({ action: z27.literal("slot.replace"), slotId: z27.string().max(200), ingredientEntryId: z27.string().max(200), newIngredientEntryId: z27.string().max(200) });
-var mapSlotListVariant = slotBase.extend({ action: z27.literal("slot.list") });
+var mapSlotAddVariant = slotBase.extend({ action: z28.literal("slot.add"), slotId: z28.string().max(200), ingredientEntryId: z28.string().max(200) });
+var mapSlotRemoveVariant = slotBase.extend({ action: z28.literal("slot.remove"), slotId: z28.string().max(200), ingredientEntryId: z28.string().max(200) });
+var mapSlotReplaceVariant = slotBase.extend({ action: z28.literal("slot.replace"), slotId: z28.string().max(200), ingredientEntryId: z28.string().max(200), newIngredientEntryId: z28.string().max(200) });
+var mapSlotListVariant = slotBase.extend({ action: z28.literal("slot.list") });
 var versionBase2 = mapVersionSchema.omit({ action: true });
-var mapVersionCommitVariant = versionBase2.extend({ action: z27.literal("version.commit") });
-var mapVersionListVariant = versionBase2.extend({ action: z27.literal("version.list") });
-var mapVersionHistoryVariant = versionBase2.extend({ action: z27.literal("version.history") });
-var mapSuggestVariant = mapSuggestSchema.extend({ action: z27.literal("suggest") });
-var mapCreateAudienceSetVariant = createAudienceMapSetSchema.extend({ action: z27.literal("create-audience-set") });
-var mapActionUnion = z27.discriminatedUnion("action", [
+var mapVersionCommitVariant = versionBase2.extend({ action: z28.literal("version.commit") });
+var mapVersionListVariant = versionBase2.extend({ action: z28.literal("version.list") });
+var mapVersionHistoryVariant = versionBase2.extend({ action: z28.literal("version.history") });
+var mapSuggestVariant = mapSuggestSchema.extend({ action: z28.literal("suggest") });
+var mapCreateAudienceSetVariant = createAudienceMapSetSchema.extend({ action: z28.literal("create-audience-set") });
+var mapActionUnion = z28.discriminatedUnion("action", [
   mapCreateVariant,
   mapGetVariant,
   mapListVariant,
@@ -14526,10 +14691,37 @@ function registerMapTools(server) {
 }
 
 // src/tools/workspace.ts
-import { z as z30 } from "zod/v3";
+import { z as z31 } from "zod/v3";
+
+// src/tools/health.ts
+import { z as z29 } from "zod/v3";
+
+// src/lib/auditView.ts
+async function buildTenantAuditView(limit) {
+  const scope = cacheScope();
+  let workspace;
+  try {
+    workspace = await getWorkspaceId();
+  } catch {
+    workspace = scope;
+  }
+  const ownScopes = [workspace, scope];
+  const log = getAuditLog(ownScopes);
+  const recent = log.slice(-limit);
+  const gatewaySeam = getMergedGatewaySeamCounters(ownScopes);
+  const logLines = [
+    `# Audit Log (last ${recent.length} of ${log.length} total)
+`,
+    ...recent.map((entry) => {
+      const toolPart = entry.toolContext ? ` [${entry.toolContext.tool}${entry.toolContext.action ? ` action=${entry.toolContext.action}` : ""}]` : "";
+      const errPart = entry.error ? ` \u2014 ${entry.error}` : "";
+      return `${entry.status === "ok" ? "\u2713" : "\u2717"} \`${entry.fn}\`${toolPart} ${entry.durationMs}ms ${entry.status}${errPart}`;
+    })
+  ];
+  return { workspace, log, recent, gatewaySeam, logLines, seamSummaryText: formatGatewaySeamSummary(gatewaySeam) };
+}
 
 // src/tools/health.ts
-import { z as z28 } from "zod/v3";
 var CALL_CATEGORIES = {
   "chain.getEntry": "read",
   "chain.batchGetEntries": "read",
@@ -14838,27 +15030,19 @@ async function handleWorkspaceStatus() {
   };
 }
 async function handleAudit2(limit) {
-  const log = getAuditLog();
-  const recent = log.slice(-limit);
-  if (recent.length === 0) {
-    return successResult("No calls recorded yet this session.", "No calls recorded yet this session.", { totalCalls: 0, calls: [] });
-  }
+  const { log, recent, gatewaySeam, logLines, seamSummaryText } = await buildTenantAuditView(limit);
+  if (recent.length === 0) return successResult(`No calls recorded yet this session.${seamSummaryText}`, "No calls recorded yet this session.", { totalCalls: 0, calls: [], gatewaySeam });
   const summary = buildSessionSummary(log);
-  const logLines = [`# Audit Log (last ${recent.length} of ${log.length} total)
-`];
-  for (const entry of recent) {
-    const icon = entry.status === "ok" ? "\u2713" : "\u2717";
-    const errPart = entry.error ? ` \u2014 ${entry.error}` : "";
-    const toolPart = entry.toolContext ? ` [${entry.toolContext.tool}${entry.toolContext.action ? ` action=${entry.toolContext.action}` : ""}]` : "";
-    logLines.push(`${icon} \`${entry.fn}\`${toolPart} ${entry.durationMs}ms ${entry.status}${errPart}`);
-  }
   const auditData = {
     totalCalls: log.length,
+    gatewaySeam,
     calls: recent.map((entry) => ({
       tool: entry.fn,
       ...entry.toolContext?.action && { action: entry.toolContext.action },
       timestamp: entry.ts,
-      ...entry.durationMs != null && { durationMs: entry.durationMs }
+      ...entry.durationMs != null && { durationMs: entry.durationMs },
+      ...entry.budgetMs != null && { budgetMs: entry.budgetMs },
+      ...entry.timedOut ? { timedOut: true } : {}
     }))
   };
   return {
@@ -14866,7 +15050,7 @@ async function handleAudit2(limit) {
 
 ---
 
-${logLines.join("\n")}` }],
+${logLines.join("\n")}${seamSummaryText}` }],
     structuredContent: success(
       `Audit: ${log.length} total calls, showing last ${recent.length}.`,
       auditData
@@ -14874,65 +15058,65 @@ ${logLines.join("\n")}` }],
   };
 }
 var HEALTH_ACTIONS = ["check", "whoami", "status", "audit", "self-test"];
-var healthSchema = z28.object({
-  action: z28.enum(HEALTH_ACTIONS).describe(
+var healthSchema = z29.object({
+  action: z29.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: z28.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
+  limit: z29.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
 });
-var healthCheckOutputSchema = z28.object({
-  healthy: z28.boolean(),
-  collections: z28.number(),
-  entries: z28.number(),
-  latencyMs: z28.number(),
-  workspace: z28.string()
+var healthCheckOutputSchema = z29.object({
+  healthy: z29.boolean(),
+  collections: z29.number(),
+  entries: z29.number(),
+  latencyMs: z29.number(),
+  workspace: z29.string()
 });
-var organisationHealthSchema = z28.object({
-  reviewed: z28.number(),
-  agreements: z28.number(),
-  disagreements: z28.number(),
-  abstentions: z28.number(),
-  agreementRate: z28.number(),
-  flags: z28.array(z28.object({
-    collection: z28.string(),
-    count: z28.number(),
-    suggestedCollection: z28.string()
+var organisationHealthSchema = z29.object({
+  reviewed: z29.number(),
+  agreements: z29.number(),
+  disagreements: z29.number(),
+  abstentions: z29.number(),
+  agreementRate: z29.number(),
+  flags: z29.array(z29.object({
+    collection: z29.string(),
+    count: z29.number(),
+    suggestedCollection: z29.string()
   }))
 });
-var healthStatusOutputSchema = z28.object({
-  stage: z28.enum(["blank", "seeded", "grounded", "connected"]).optional().default("seeded"),
-  scoringVersion: z28.enum(["v1", "v2"]).optional().default("v1"),
-  readinessScore: z28.number(),
-  activeEntries: z28.number(),
-  totalRelations: z28.number(),
-  orphanedEntries: z28.number(),
-  gaps: z28.array(z28.object({ id: z28.string(), label: z28.string(), guidance: z28.string() })),
+var healthStatusOutputSchema = z29.object({
+  stage: z29.enum(["blank", "seeded", "grounded", "connected"]).optional().default("seeded"),
+  scoringVersion: z29.enum(["v1", "v2"]).optional().default("v1"),
+  readinessScore: z29.number(),
+  activeEntries: z29.number(),
+  totalRelations: z29.number(),
+  orphanedEntries: z29.number(),
+  gaps: z29.array(z29.object({ id: z29.string(), label: z29.string(), guidance: z29.string() })),
   organisationHealth: organisationHealthSchema.optional()
 });
-var healthAuditOutputSchema = z28.object({
-  totalCalls: z28.number(),
-  calls: z28.array(z28.object({
-    tool: z28.string(),
-    action: z28.string().optional(),
-    timestamp: z28.string(),
-    durationMs: z28.number().optional()
+var healthAuditOutputSchema = z29.object({
+  totalCalls: z29.number(),
+  calls: z29.array(z29.object({
+    tool: z29.string(),
+    action: z29.string().optional(),
+    timestamp: z29.string(),
+    durationMs: z29.number().optional()
   }))
 });
-var healthWhoamiOutputSchema = z28.object({
-  workspaceId: z28.string(),
-  workspaceName: z28.string(),
-  scope: z28.string(),
-  sessionId: z28.union([z28.string(), z28.null()]),
-  oriented: z28.boolean()
+var healthWhoamiOutputSchema = z29.object({
+  workspaceId: z29.string(),
+  workspaceName: z29.string(),
+  scope: z29.string(),
+  sessionId: z29.union([z29.string(), z29.null()]),
+  oriented: z29.boolean()
 });
-var selfTestOutputSchema = z28.object({
-  passed: z28.number(),
-  failed: z28.number(),
-  total: z28.number(),
-  results: z28.array(z28.object({
-    tool: z28.string(),
-    valid: z28.boolean(),
-    error: z28.string().optional()
+var selfTestOutputSchema = z29.object({
+  passed: z29.number(),
+  failed: z29.number(),
+  total: z29.number(),
+  results: z29.array(z29.object({
+    tool: z29.string(),
+    valid: z29.boolean(),
+    error: z29.string().optional()
   }))
 });
 function handleSelfTest(server) {
@@ -14983,9 +15167,9 @@ function handleSelfTest(server) {
 }
 
 // src/tools/usage.ts
-import { z as z29 } from "zod/v3";
-var usageSummarySchema = z29.object({
-  periodDays: z29.number().min(1).max(90).optional().describe("Number of days to look back (default 30, max 90)")
+import { z as z30 } from "zod/v3";
+var usageSummarySchema = z30.object({
+  periodDays: z30.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();
@@ -15157,35 +15341,35 @@ var WORKSPACE_ACTIONS = [
   "proposals-respond",
   "proposals-count"
 ];
-var workspaceSchema = z30.object({
-  action: z30.enum(WORKSPACE_ACTIONS).describe(
+var workspaceSchema = z31.object({
+  action: z31.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: z30.number().min(1).max(50).optional().describe("For 'audit': how many recent calls to show (max 50, default 20)."),
-  periodDays: z30.number().min(1).max(90).optional().describe("For 'usage': number of days to look back (default 30, max 90)."),
-  status: z30.enum(["open", "approved", "objected", "expired"]).optional().describe("For 'proposals-list': filter by status (default: open)."),
-  proposalId: z30.string().max(200).optional().describe("For 'proposals-respond': proposal ID."),
-  verdict: z30.enum(["approve", "reject"]).optional().describe("For 'proposals-respond': approve or reject."),
-  reason: z30.string().max(2e3).optional().describe("For 'proposals-respond': reason for the verdict (required when rejecting).")
+  limit: z31.number().min(1).max(50).optional().describe("For 'audit': how many recent calls to show (max 50, default 20)."),
+  periodDays: z31.number().min(1).max(90).optional().describe("For 'usage': number of days to look back (default 30, max 90)."),
+  status: z31.enum(["open", "approved", "objected", "expired"]).optional().describe("For 'proposals-list': filter by status (default: open)."),
+  proposalId: z31.string().max(200).optional().describe("For 'proposals-respond': proposal ID."),
+  verdict: z31.enum(["approve", "reject"]).optional().describe("For 'proposals-respond': approve or reject."),
+  reason: z31.string().max(2e3).optional().describe("For 'proposals-respond': reason for the verdict (required when rejecting).")
 });
-var workspaceCheckVariant = z30.object({ action: z30.literal("check") });
-var workspaceWhoamiVariant = z30.object({ action: z30.literal("whoami") });
-var workspaceStatusVariant = z30.object({ action: z30.literal("status") });
-var workspaceAuditVariant = z30.object({ action: z30.literal("audit"), limit: z30.number().min(1).max(50).optional().default(20) });
-var workspaceSelfTestVariant = z30.object({ action: z30.literal("self-test") });
-var workspaceUsageVariant = z30.object({ action: z30.literal("usage"), periodDays: z30.number().min(1).max(90).optional() });
-var workspaceProposalsListVariant = z30.object({
-  action: z30.literal("proposals-list"),
-  status: z30.enum(["open", "approved", "objected", "expired"]).optional()
+var workspaceCheckVariant = z31.object({ action: z31.literal("check") });
+var workspaceWhoamiVariant = z31.object({ action: z31.literal("whoami") });
+var workspaceStatusVariant = z31.object({ action: z31.literal("status") });
+var workspaceAuditVariant = z31.object({ action: z31.literal("audit"), limit: z31.number().min(1).max(50).optional().default(20) });
+var workspaceSelfTestVariant = z31.object({ action: z31.literal("self-test") });
+var workspaceUsageVariant = z31.object({ action: z31.literal("usage"), periodDays: z31.number().min(1).max(90).optional() });
+var workspaceProposalsListVariant = z31.object({
+  action: z31.literal("proposals-list"),
+  status: z31.enum(["open", "approved", "objected", "expired"]).optional()
 });
-var workspaceProposalsRespondVariant = z30.object({
-  action: z30.literal("proposals-respond"),
-  proposalId: z30.string().max(200),
-  verdict: z30.enum(["approve", "reject"]),
-  reason: z30.string().max(2e3).optional()
+var workspaceProposalsRespondVariant = z31.object({
+  action: z31.literal("proposals-respond"),
+  proposalId: z31.string().max(200),
+  verdict: z31.enum(["approve", "reject"]),
+  reason: z31.string().max(2e3).optional()
 });
-var workspaceProposalsCountVariant = z30.object({ action: z30.literal("proposals-count") });
-var workspaceActionUnion = z30.discriminatedUnion("action", [
+var workspaceProposalsCountVariant = z31.object({ action: z31.literal("proposals-count") });
+var workspaceActionUnion = z31.discriminatedUnion("action", [
   workspaceCheckVariant,
   workspaceWhoamiVariant,
   workspaceStatusVariant,
@@ -15241,7 +15425,7 @@ function registerWorkspaceTools(server) {
 }
 
 // src/tools/feedback.ts
-import { z as z31 } from "zod/v3";
+import { z as z32 } from "zod/v3";
 
 // src/lib/productFeedbackConstants.ts
 var PRODUCT_FEEDBACK_CATEGORIES = ["bug", "friction", "idea", "praise", "other"];
@@ -15252,9 +15436,9 @@ var VENDOR_SETTABLE_STATUSES = PRODUCT_FEEDBACK_STATUSES.filter(
 
 // src/tools/feedback.ts
 var actions = ["submit", "list", "queue", "note", "group", "status"];
-var category = z31.enum(PRODUCT_FEEDBACK_CATEGORIES);
-var status = z31.enum(PRODUCT_FEEDBACK_STATUSES);
-var vendorStatus = z31.enum(VENDOR_SETTABLE_STATUSES);
+var category = z32.enum(PRODUCT_FEEDBACK_CATEGORIES);
+var status = z32.enum(PRODUCT_FEEDBACK_STATUSES);
+var vendorStatus = z32.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;
@@ -15263,32 +15447,32 @@ var byteLimitMessage = (field) => ({
 });
 var MESSAGE_DISPLAY_LIMIT = 1e3;
 var FULL_MESSAGE_MAX_LIMIT = 5;
-var feedbackSchema = z31.object({
-  action: z31.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: z31.string().max(1e4).optional().describe("Required for submit: the product feedback text (max 10,000 chars and 10,240 UTF-8 bytes)."),
+var feedbackSchema = z32.object({
+  action: z32.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: z32.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: z31.string().max(1e3).optional().describe("Optional submit command context; argument values are scrubbed server-side."),
-  route: z31.string().max(500).optional().describe("Optional submit route context."),
-  client: z31.string().max(100).optional().describe("Optional submit client label."),
-  feedbackId: z31.string().max(200).optional().describe("Required for note/status: target feedback ID."),
-  feedbackIds: z31.array(z31.string().max(200)).max(100).optional().describe("Required for group: 1\u2013100 target feedback IDs."),
-  note: z31.string().max(4e3).optional().describe("Required for note: replacement triage note (max 10,240 UTF-8 bytes)."),
+  command: z32.string().max(1e3).optional().describe("Optional submit command context; argument values are scrubbed server-side."),
+  route: z32.string().max(500).optional().describe("Optional submit route context."),
+  client: z32.string().max(100).optional().describe("Optional submit client label."),
+  feedbackId: z32.string().max(200).optional().describe("Required for note/status: target feedback ID."),
+  feedbackIds: z32.array(z32.string().max(200)).max(100).optional().describe("Required for group: 1\u2013100 target feedback IDs."),
+  note: z32.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: z31.string().min(1).max(200).nullable().optional().describe("Group filter, or required group destination; null explicitly clears grouping."),
-  workspaceId: z31.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: z31.number().optional().describe("Queue-only lower createdAt window bound (inclusive) in epoch milliseconds."),
-  before: z31.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: z31.number().int().min(1).max(100).optional().describe("list/queue row limit, default 50, maximum 100."),
-  cursor: z31.string().max(2e3).optional().describe("Opaque pagination cursor from a previous list/queue response (continueCursor); omit for the first page."),
-  full: z31.boolean().optional().describe(`list/queue only: return untruncated messages; allowed only when limit <= ${FULL_MESSAGE_MAX_LIMIT}.`)
+  groupId: z32.string().min(1).max(200).nullable().optional().describe("Group filter, or required group destination; null explicitly clears grouping."),
+  workspaceId: z32.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: z32.number().optional().describe("Queue-only lower createdAt window bound (inclusive) in epoch milliseconds."),
+  before: z32.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: z32.number().int().min(1).max(100).optional().describe("list/queue row limit, default 50, maximum 100."),
+  cursor: z32.string().max(2e3).optional().describe("Opaque pagination cursor from a previous list/queue response (continueCursor); omit for the first page."),
+  full: z32.boolean().optional().describe(`list/queue only: return untruncated messages; allowed only when limit <= ${FULL_MESSAGE_MAX_LIMIT}.`)
 });
-var union = z31.discriminatedUnion("action", [
-  z31.object({ action: z31.literal("submit"), message: z31.string().min(1).max(1e4).refine(fitsGatewayBytes, byteLimitMessage("message")), category: category.optional(), command: z31.string().max(1e3).optional(), route: z31.string().max(500).optional(), client: z31.string().max(100).optional() }),
-  z31.object({ action: z31.literal("list"), status: status.optional(), limit: z31.number().int().min(1).max(100).optional(), cursor: z31.string().max(2e3).optional(), full: z31.boolean().optional() }),
-  z31.object({ action: z31.literal("queue"), status: status.optional(), category: category.optional(), groupId: z31.string().min(1).max(200).optional(), workspaceId: z31.string().max(200).optional(), since: z31.number().optional(), before: z31.number().optional(), limit: z31.number().int().min(1).max(100).optional(), cursor: z31.string().max(2e3).optional(), full: z31.boolean().optional() }),
-  z31.object({ action: z31.literal("note"), feedbackId: z31.string().min(1).max(200), note: z31.string().max(4e3).refine(fitsGatewayBytes, byteLimitMessage("note")) }),
-  z31.object({ action: z31.literal("group"), feedbackIds: z31.array(z31.string().min(1).max(200)).min(1).max(100), groupId: z31.string().min(1).max(200).nullable() }),
-  z31.object({ action: z31.literal("status"), feedbackId: z31.string().min(1).max(200), status: vendorStatus })
+var union = z32.discriminatedUnion("action", [
+  z32.object({ action: z32.literal("submit"), message: z32.string().min(1).max(1e4).refine(fitsGatewayBytes, byteLimitMessage("message")), category: category.optional(), command: z32.string().max(1e3).optional(), route: z32.string().max(500).optional(), client: z32.string().max(100).optional() }),
+  z32.object({ action: z32.literal("list"), status: status.optional(), limit: z32.number().int().min(1).max(100).optional(), cursor: z32.string().max(2e3).optional(), full: z32.boolean().optional() }),
+  z32.object({ action: z32.literal("queue"), status: status.optional(), category: category.optional(), groupId: z32.string().min(1).max(200).optional(), workspaceId: z32.string().max(200).optional(), since: z32.number().optional(), before: z32.number().optional(), limit: z32.number().int().min(1).max(100).optional(), cursor: z32.string().max(2e3).optional(), full: z32.boolean().optional() }),
+  z32.object({ action: z32.literal("note"), feedbackId: z32.string().min(1).max(200), note: z32.string().max(4e3).refine(fitsGatewayBytes, byteLimitMessage("note")) }),
+  z32.object({ action: z32.literal("group"), feedbackIds: z32.array(z32.string().min(1).max(200)).min(1).max(100), groupId: z32.string().min(1).max(200).nullable() }),
+  z32.object({ action: z32.literal("status"), feedbackId: z32.string().min(1).max(200), status: vendorStatus })
 ]);
 var specs = {
   submit: { params: ["message", "category", "command", "route", "client"], description: "message is required; category defaults to other." },
@@ -15415,34 +15599,34 @@ function registerFeedbackTool(server) {
 }
 
 // src/tools/shape.ts
-import { z as z32 } from "zod/v3";
+import { z as z33 } 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 = z32.object({
-  action: z32.enum(SHAPE_ACTIONS).describe(
+var shapeSchema = z33.object({
+  action: z33.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: z32.enum(LIST_DISPOSITIONS).optional().describe(
+  disposition: z33.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: z32.enum(LIST_OUTCOMES).optional().describe(
+  outcome: z33.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: z32.number().min(1).max(200).optional().describe("For 'list': max rows (default 50, max 200)."),
-  rowId: z32.string().max(200).optional().describe("For 'show'/'agree'/'dismiss': the advisory row id."),
-  reason: z32.string().max(1e3).optional().describe("For 'agree'/'dismiss': optional reason (capped at 1000 chars).")
+  limit: z33.number().min(1).max(200).optional().describe("For 'list': max rows (default 50, max 200)."),
+  rowId: z33.string().max(200).optional().describe("For 'show'/'agree'/'dismiss': the advisory row id."),
+  reason: z33.string().max(1e3).optional().describe("For 'agree'/'dismiss': optional reason (capped at 1000 chars).")
 });
-var shapeListVariant = z32.object({
-  action: z32.literal("list"),
-  disposition: z32.enum(LIST_DISPOSITIONS).optional(),
-  outcome: z32.enum(LIST_OUTCOMES).optional(),
-  limit: z32.number().min(1).max(200).optional()
+var shapeListVariant = z33.object({
+  action: z33.literal("list"),
+  disposition: z33.enum(LIST_DISPOSITIONS).optional(),
+  outcome: z33.enum(LIST_OUTCOMES).optional(),
+  limit: z33.number().min(1).max(200).optional()
 });
-var shapeShowVariant = z32.object({ action: z32.literal("show"), rowId: z32.string().max(200) });
-var shapeAgreeVariant = z32.object({ action: z32.literal("agree"), rowId: z32.string().max(200), reason: z32.string().max(1e3).optional() });
-var shapeDismissVariant = z32.object({ action: z32.literal("dismiss"), rowId: z32.string().max(200), reason: z32.string().max(1e3).optional() });
-var shapeActionUnion = z32.discriminatedUnion("action", [
+var shapeShowVariant = z33.object({ action: z33.literal("show"), rowId: z33.string().max(200) });
+var shapeAgreeVariant = z33.object({ action: z33.literal("agree"), rowId: z33.string().max(200), reason: z33.string().max(1e3).optional() });
+var shapeDismissVariant = z33.object({ action: z33.literal("dismiss"), rowId: z33.string().max(200), reason: z33.string().max(1e3).optional() });
+var shapeActionUnion = z33.discriminatedUnion("action", [
   shapeListVariant,
   shapeShowVariant,
   shapeAgreeVariant,
@@ -16109,12 +16293,12 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 }
 
 // src/prompts/index.ts
-import { z as z33 } from "zod/v3";
+import { z as z34 } 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: z33.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z34.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);
@@ -16167,7 +16351,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: z33.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z34.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(
@@ -16203,7 +16387,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: z33.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z34.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);
@@ -16241,8 +16425,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: z33.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
-      domain: z33.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z34.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z34.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" });
@@ -16518,4 +16702,4 @@ export {
   createProductBrainServer,
   initFeatureFlags
 };
-//# sourceMappingURL=chunk-W66ODVGP.js.map
+//# sourceMappingURL=chunk-PEAWB3EE.js.map