@productbrain/mcp 0.0.1-beta.6507 → 0.0.1-beta.6513

package/dist/{chunk-GBEBTAN6.js → chunk-NKO44SHW.js}

@@ -41,7 +41,7 @@ import {
   trackSessionCaptureRate,
   trackWriteBackHintServed,
   trackZeroCaptureAuditFired
-} from "./chunk-GLLZURWD.js";
+} from "./chunk-KL74MUS5.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -292,10 +292,6 @@ function parseOrFail(schema, args) {
     result: { content: textContent(msg), structuredContent: validationError(msg) }
   };
 }
-function unknownAction(action, valid) {
-  const msg = `Unknown action '${action}'. Valid actions: ${valid.join(", ")}.`;
-  return { content: textContent(msg), structuredContent: validationError(msg) };
-}
 function successResult(text, summary, data, next) {
   return { content: textContent(text), structuredContent: success(summary, data, next) };
 }
@@ -565,8 +561,12 @@ var TOOL_NAME_MIGRATIONS = /* @__PURE__ */ new Map([
   ["get-usage-summary", 'workspace action="usage"'],
   ["audit", 'quality action="audit"'],
   ["governance-proposals", 'workspace action="proposals-list|proposals-respond|proposals-count" (list/respond/count \u2192 proposals-<same>)'],
-  ["chain-version", 'chain action="version.*" (commit/list/diff/revert/history \u2192 version.<same>)'],
-  ["chain-branch", 'chain-review action="branch.*" (create/list/merge/conflicts \u2192 branch.<same>)']
+  // WP-757 TASK-224 F2 (DEC-1722): the `chain` and `chain-review` MCP tools these two rows
+  // targeted are themselves deleted along with gitchain — retargeted from executable
+  // replacements to NOTICE rows (no equivalent command exists), same shape as
+  // `create-collection`/`map` above, so the coach never points an agent at a second dead name.
+  ["chain-version", "closed \u2014 the `chain` MCP tool has been retired along with gitchain. There is no supported way to commit/list/diff/revert/history a chain version through MCP."],
+  ["chain-branch", "closed \u2014 the `chain-review` MCP tool has been retired along with gitchain. There is no supported way to create/list/merge/check conflicts on a chain branch through MCP."]
 ]);
 function isExecutableReference(value) {
   return /^[\w./-]+(\s+action="[^"]*")?$/.test(value);
@@ -9617,7 +9617,7 @@ var IMPLEMENTATION_REVIEW_WORKFLOW_DESCRIPTOR = {
 
 ## Your Behavior
 
-1. **Tool-heavy, not chat-heavy.** Each round calls specific tools: orient, quality, verify, chain-review, context action=gather, review-against-rules. Use Context7 **CLI** (\`npx ctx7 library\` then \`npx ctx7 docs\` \u2014 project-local after \`npm install\`; avoid cold \`npx ctx7@latest\` in short-timeout shells) for relevant testing and framework docs \u2014 not for Chain truth. Do not use Context7 MCP.
+1. **Tool-heavy, not chat-heavy.** Each round calls specific tools: orient, quality, verify, context action=gather, review-against-rules. Use Context7 **CLI** (\`npx ctx7 library\` then \`npx ctx7 docs\` \u2014 project-local after \`npm install\`; avoid cold \`npx ctx7@latest\` in short-timeout shells) for relevant testing and framework docs \u2014 not for Chain truth. Do not use Context7 MCP.
 2. **Spawn sub-agents** for parallel review: (a) code/architecture review, (b) test honesty (did we edit tests to pass or do they validate real behavior?). Max 2 agents in parallel, 30s budget each. **Constrain each sub-agent to the stated review scope only.**
 3. **Fix-as-you-go (FEAT-172).** When you find a HIGH or MEDIUM issue: fix it immediately, verify (lints, types), then proceed. The user sees clean work, not a list of issues. Only defer if estimated >5 min \u2014 capture deferred items as tensions. If user says "skip", capture as tension and continue.
 4. **Chain is SSOT.** Call orient or start first. Use entries action=search and context action=gather to load relevant BETs, DECs, BRs. If findings conflict with Chain entries, report the conflict and cite the entry ID.
@@ -9629,8 +9629,7 @@ var IMPLEMENTATION_REVIEW_WORKFLOW_DESCRIPTOR = {
 ## Tool Usage
 
 - \`orient\` or \`start\` \u2014 governance, active work packages, stale entries
-- \`quality action=check entryId="<BET-ID>"\` \u2014 score against collection criteria
-- \`chain-review action=gate chainEntryId="<id>"\` \u2014 coherence gate for chains
+- \`quality action=check entryId="<BET-ID>"\` \u2014 score against collection criteria (chain-type entries included; the chain-review tool this row named is retired, DEC-1722)
 - \`quality action=verify-chain\` \u2014 glossary code mappings, cross-references vs codebase
 - \`review-against-rules\` (domain) \u2014 business rule compliance
 - \`context action=gather task="implementation review for [BET-ID]"\` \u2014 related knowledge
@@ -9671,8 +9670,8 @@ This block is the final deliverable of the review. Everything else is supporting
       num: "02",
       label: "Standards & Chain Coherence",
       type: "open",
-      instruction: "Run quality check, chain-review gate (if applicable), review-against-rules, and codebase coherence gate. Is the implementation coherent with the Chain SSOT? Did it introduce or fix registry drift?",
-      facilitatorGuidance: "For the BET/entry: quality action=check entryId='<ID>'. If the work produced a chain artifact: chain-review action=gate. Call review-against-rules with the relevant domain (e.g. 'Governance & Decision-Making'). **Codebase Coherence Gate (BET-99/FEAT-183):** Compare the Codebase Coherence section from Round 01's orient output against the current state. If orient showed coherence gaps and this implementation touched registry files (collection colors, routes, classification, renderers, etc.), check whether gaps increased or decreased. Gaps increased \u2192 flag as 'Coherence: WARN \u2014 N new gaps introduced' and list them. Gaps decreased \u2192 celebrate as 'Coherence: PASS \u2014 N gaps fixed.' No change \u2192 note as 'Coherence: PASS \u2014 no change.' If Round 01 did not show a coherence section, skip the gate \u2014 do not block on missing baseline. Present: quality score, gate result, rule compliance, coherence gate verdict.",
+      instruction: "Run quality check (chain-type entries included \u2014 the chain-review tool is retired, DEC-1722), review-against-rules, and codebase coherence gate. Is the implementation coherent with the Chain SSOT? Did it introduce or fix registry drift?",
+      facilitatorGuidance: "For the BET/entry: quality action=check entryId='<ID>' \u2014 this covers a chain artifact too now. Call review-against-rules with the relevant domain (e.g. 'Governance & Decision-Making'). **Codebase Coherence Gate (BET-99/FEAT-183):** Compare the Codebase Coherence section from Round 01's orient output against the current state. If orient showed coherence gaps and this implementation touched registry files (collection colors, routes, classification, renderers, etc.), check whether gaps increased or decreased. Gaps increased \u2192 flag as 'Coherence: WARN \u2014 N new gaps introduced' and list them. Gaps decreased \u2192 celebrate as 'Coherence: PASS \u2014 N gaps fixed.' No change \u2192 note as 'Coherence: PASS \u2014 no change.' If Round 01 did not show a coherence section, skip the gate \u2014 do not block on missing baseline. Present: quality score, gate result, rule compliance, coherence gate verdict.",
       outputSchema: {
         field: "standards",
         description: "Quality score, gate result, rule compliance, coherence gate verdict (improved/degraded/unchanged)",
@@ -12440,735 +12439,11 @@ async function handleStatus() {
   };
 }
 
-// src/tools/gitchain.ts
-import { z as z27 } from "zod/v3";
-
-// src/lib/versionDisplay.ts
-function toVersionDisplay(version) {
-  if (version == null || version === 0) return "Draft";
-  return `v${version}`;
-}
-
-// src/tools/gitchain.ts
-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: 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 = 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 = 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 = 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: 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]) => {
-    const filled = typeof content === "string" && content.length > 0;
-    const preview = filled ? content.substring(0, 80) + (content.length > 80 ? "..." : "") : "(empty)";
-    return `  - **${id}**: ${preview}`;
-  }).join("\n");
-}
-async function handleChainCrud({ action, chainEntryId, title, chainTypeId, description, linkId, content, status: status2, author, ownerTeamEntryId, ownerRoleEntryId }) {
-  if (action === "create") {
-    if (!title) {
-      return validationResult("A `title` is required to create a process.");
-    }
-    const result2 = await kernelMutation(
-      "gitchain.createChain",
-      { title, chainTypeId, description, author, ownerTeamEntryId, ownerRoleEntryId }
-    );
-    return {
-      content: [{
-        type: "text",
-        text: `# Process Created
-
-- **Entry ID:** \`${result2.entryId}\`
-- **Title:** ${title}
-- **Type:** ${chainTypeId}
-- **Status:** draft
-
-Use \`chain action=edit chainEntryId="${result2.entryId}" linkId="problem" content="..."\` to start filling in links.`
-      }],
-      structuredContent: success(
-        `Created process '${title}' (${result2.entryId}), type: ${chainTypeId}.`,
-        { entryId: result2.entryId, title, chainTypeId, status: "draft" },
-        [{ tool: "chain", description: "Edit a link", parameters: { action: "edit", chainEntryId: result2.entryId, linkId: "problem" } }]
-      )
-    };
-  }
-  if (action === "get") {
-    if (!chainEntryId) {
-      return validationResult("A `chainEntryId` is required.");
-    }
-    const chain = await kernelQuery("gitchain.getChain", { chainEntryId });
-    if (!chain) {
-      return {
-        content: [{ type: "text", text: `Process "${chainEntryId}" not found.` }],
-        structuredContent: failure(
-          "NOT_FOUND",
-          `Process "${chainEntryId}" not found.`,
-          "Use chain action=list to find available processes.",
-          [{ tool: "chain", description: "List processes", parameters: { action: "list" } }]
-        )
-      };
-    }
-    const scoreSection = chain.scores ? `
-## Coherence: ${chain.coherenceScore}%
-
-` + chain.scores.sections.map((s) => `- **${s.key}**: ${s.power}/100 (${"\u2605".repeat(Math.min(s.stars ?? 0, 5))}${"\u2606".repeat(Math.max(0, 5 - (s.stars ?? 0)))})`).join("\n") : "";
-    return {
-      content: [{
-        type: "text",
-        text: `# ${chain.name}
-
-- **Entry ID:** \`${chain.entryId}\`
-- **Type:** ${chain.chainTypeName}
-- **Status:** ${chain.status}
-- **Links filled:** ${chain.filledCount}/${chain.totalCount}
-- **Version:** ${toVersionDisplay(chain.currentVersion)}
-- **Created by:** ${chain.createdBy ?? "unknown"}
-- **History events:** ${chain.historyCount}
-` + scoreSection + `
-
-## Links
-
-` + linkSummary(chain.links)
-      }],
-      structuredContent: success(
-        `${chain.name}: ${chain.filledCount}/${chain.totalCount} links, coherence ${chain.coherenceScore}%, ${toVersionDisplay(chain.currentVersion)}.`,
-        { entryId: chain.entryId, name: chain.name, status: chain.status, filledCount: chain.filledCount, totalCount: chain.totalCount, coherenceScore: chain.coherenceScore, version: chain.currentVersion ?? null, versionDisplay: toVersionDisplay(chain.currentVersion) }
-      )
-    };
-  }
-  if (action === "list") {
-    const chains = await kernelQuery("gitchain.listChains", { chainTypeId, status: status2 });
-    if (chains.length === 0) {
-      return {
-        content: [{ type: "text", text: "No processes found. Use `chain action=create` to create one." }],
-        structuredContent: success(
-          "No processes found.",
-          { chains: [], total: 0 },
-          [{ tool: "chain", description: "Create a process", parameters: { action: "create" } }]
-        )
-      };
-    }
-    const formatted = chains.map(
-      (c) => `- **\`${c.entryId}\`** ${c.name} \u2014 ${c.chainTypeId} \xB7 ${c.filledCount}/${c.totalCount} links \xB7 coherence: ${c.coherenceScore}% \xB7 status: ${c.status}`
-    ).join("\n");
-    return {
-      content: [{ type: "text", text: `# Chains (${chains.length})
-
-${formatted}` }],
-      structuredContent: success(
-        `Found ${chains.length} process(es).`,
-        { total: chains.length }
-      )
-    };
-  }
-  if (action === "edit") {
-    if (!chainEntryId) {
-      return validationResult("A `chainEntryId` is required.");
-    }
-    if (!linkId) {
-      return validationResult("A `linkId` is required (e.g. problem, insight, choice, action, outcome).");
-    }
-    if (!content) {
-      return validationResult("The `content` for the link is required.");
-    }
-    const result2 = await kernelMutation("gitchain.editLink", { chainEntryId, linkId, content, author });
-    const remedyBlock = result2.strategyLinkRemedy ? `
-
-**Still draft:** ${result2.strategyLinkRemedy}` : "";
-    return {
-      content: [{
-        type: "text",
-        text: `# Link Updated
-
-- **Chain:** \`${result2.entryId}\`
-- **Link:** ${result2.linkId}
-- **Chain status:** ${result2.status}
-- **Content length:** ${content.length} chars${remedyBlock}
-
-Use \`chain action=get\` to see the full chain with updated scores.`
-      }],
-      structuredContent: success(
-        `Updated link "${result2.linkId}" on ${result2.entryId}. Status: ${result2.status}.${result2.strategyLinkRemedy ? ` ${result2.strategyLinkRemedy}` : ""}`,
-        { entryId: result2.entryId, linkId: result2.linkId, status: result2.status, contentLength: content.length, ...result2.strategyLinkRemedy ? { strategyLinkRemedy: result2.strategyLinkRemedy } : {} },
-        [{ tool: "chain", description: "View full chain", parameters: { action: "get", chainEntryId } }]
-      )
-    };
-  }
-  return unknownAction(action, ["create", "get", "list", "edit"]);
-}
-async function handleChainVersion({ action, chainEntryId, commitMessage, versionA, versionB, toVersion, author }) {
-  if (action === "commit") {
-    if (!commitMessage) {
-      return validationResult("A `commitMessage` is required.");
-    }
-    const result2 = await kernelMutation("gitchain.commitChain", { chainEntryId, commitMessage, author });
-    const warning = result2.commitLintWarning ? `
-
-> **Lint warning:** ${result2.commitLintWarning}` : "";
-    return {
-      content: [{
-        type: "text",
-        text: `# Committed v${result2.version}
-
-- **Chain:** \`${result2.entryId}\`
-- **Version:** ${result2.version}
-- **Message:** ${commitMessage}
-- **Coherence:** ${result2.coherenceScore}%
-- **Links modified:** ${result2.linksModified.length > 0 ? result2.linksModified.join(", ") : "none"}
-` + warning
-      }],
-      structuredContent: success(
-        `Committed v${result2.version} on ${result2.entryId}. Coherence: ${result2.coherenceScore}%.`,
-        { entryId: result2.entryId, version: result2.version, versionDisplay: toVersionDisplay(result2.version), coherenceScore: result2.coherenceScore, linksModified: result2.linksModified, lintWarning: result2.commitLintWarning }
-      )
-    };
-  }
-  if (action === "list") {
-    const commits = await kernelQuery("gitchain.listCommits", { chainEntryId });
-    if (commits.length === 0) {
-      return {
-        content: [{ type: "text", text: `No commits found for chain "${chainEntryId}". Use \`chain action=version.commit\` to create the first snapshot.` }],
-        structuredContent: success(
-          `No commits for ${chainEntryId}.`,
-          { chainEntryId, commits: [], total: 0 },
-          [{ tool: "chain", description: "Commit chain", parameters: { action: "version.commit", chainEntryId } }]
-        )
-      };
-    }
-    const formatted = commits.map((c) => {
-      const date = new Date(c.createdAt).toISOString().replace("T", " ").substring(0, 19);
-      const msg = c.commitMessage ?? c.changeNote ?? "(no message)";
-      const links = c.linksModified?.length > 0 ? ` [${c.linksModified.join(", ")}]` : "";
-      return `- **v${c.version}** ${date} by ${c.author} \u2014 ${msg}${links} (${c.versionStatus})`;
-    }).join("\n");
-    return {
-      content: [{ type: "text", text: `# Commits for ${chainEntryId} (${commits.length})
-
-${formatted}` }],
-      structuredContent: success(
-        `${commits.length} commit(s) for ${chainEntryId}.`,
-        { chainEntryId, total: commits.length }
-      )
-    };
-  }
-  if (action === "diff") {
-    if (versionA == null || versionB == null) {
-      return validationResult("Both `versionA` and `versionB` are required for diff.");
-    }
-    const diff = await kernelMutation("gitchain.diffVersions", { chainEntryId, versionA, versionB });
-    let text = `# Diff: v${versionA} \u2192 v${versionB}
-
-- **Chain:** \`${diff.chainEntryId}\`
-- **Coherence:** ${diff.coherenceBefore}% \u2192 ${diff.coherenceAfter}% (${diff.coherenceDelta >= 0 ? "+" : ""}${diff.coherenceDelta})
-- **Links changed:** ${diff.linksChanged.length > 0 ? diff.linksChanged.join(", ") : "none"}
-`;
-    for (const ld of diff.linkDiffs) {
-      if (ld.status === "unchanged") continue;
-      text += `
-## ${ld.linkId} (${ld.status})
-
-`;
-      const wordDiff = diff.wordDiffs[ld.linkId];
-      if (wordDiff?.length > 0) {
-        for (const w of wordDiff) {
-          if (w.type === "delete") text += `~~${w.value.substring(0, 200)}~~`;
-          else if (w.type === "insert") text += `**${w.value.substring(0, 200)}**`;
-          else text += w.value.substring(0, 200);
-        }
-        text += "\n";
-      }
-    }
-    return {
-      content: [{ type: "text", text }],
-      structuredContent: success(
-        `Diff v${versionA} \u2192 v${versionB}: coherence ${diff.coherenceBefore}% \u2192 ${diff.coherenceAfter}%, ${diff.linksChanged.length} link(s) changed.`,
-        { chainEntryId: diff.chainEntryId, versionA, versionB, coherenceBefore: diff.coherenceBefore, coherenceAfter: diff.coherenceAfter, coherenceDelta: diff.coherenceDelta, linksChanged: diff.linksChanged }
-      )
-    };
-  }
-  if (action === "revert") {
-    if (toVersion == null) {
-      return validationResult("A `toVersion` is required for revert.");
-    }
-    const result2 = await kernelMutation("gitchain.revertChain", { chainEntryId, toVersion, author });
-    return {
-      content: [{
-        type: "text",
-        text: `# Reverted
-
-- **Chain:** \`${result2.entryId}\`
-- **Reverted to:** v${result2.revertedTo}
-- **New version:** v${result2.newVersion}
-- **Links affected:** ${result2.linksModified.length > 0 ? result2.linksModified.join(", ") : "none"}
-
-History is preserved \u2014 this created a new version, not a destructive reset.`
-      }],
-      structuredContent: success(
-        `Reverted ${result2.entryId} to v${result2.revertedTo}. New version: v${result2.newVersion}.`,
-        { entryId: result2.entryId, revertedTo: result2.revertedTo, revertedToDisplay: toVersionDisplay(result2.revertedTo), newVersion: result2.newVersion, newVersionDisplay: toVersionDisplay(result2.newVersion), linksModified: result2.linksModified }
-      )
-    };
-  }
-  if (action === "history") {
-    const history = await kernelQuery("gitchain.getHistory", { chainEntryId });
-    if (history.length === 0) {
-      return {
-        content: [{ type: "text", text: `No history found for chain "${chainEntryId}".` }],
-        structuredContent: success(
-          `No history for ${chainEntryId}.`,
-          { chainEntryId, events: [], total: 0 }
-        )
-      };
-    }
-    const formatted = history.sort((a, b) => b.timestamp - a.timestamp).map((h) => {
-      const date = new Date(h.timestamp).toISOString().replace("T", " ").substring(0, 19);
-      return `- **${date}** [${h.event}] by ${h.changedBy ?? "unknown"} \u2014 ${h.note ?? ""}`;
-    }).join("\n");
-    return {
-      content: [{ type: "text", text: `# History for ${chainEntryId} (${history.length} events)
-
-${formatted}` }],
-      structuredContent: success(
-        `${history.length} history event(s) for ${chainEntryId}.`,
-        { chainEntryId, total: history.length }
-      )
-    };
-  }
-  return unknownAction(action, ["commit", "list", "diff", "revert", "history"]);
-}
-async function handleChainBranch({ action, chainEntryId, branchName, strategy, author }) {
-  if (action === "create") {
-    const result2 = await kernelMutation("gitchain.createBranch", { chainEntryId, name: branchName, author });
-    return {
-      content: [{
-        type: "text",
-        text: `# Branch Created
-
-- **Name:** ${result2.name}
-- **Based on:** v${result2.baseVersion}
-- **Chain:** \`${chainEntryId}\`
-
-Edit links and commit on this branch, then use \`chain-review action=branch.merge\` to land changes.`
-      }],
-      structuredContent: success(
-        `Created branch "${result2.name}" based on v${result2.baseVersion}.`,
-        { branchId: result2.branchId, name: result2.name, baseVersion: result2.baseVersion, chainEntryId },
-        [{ tool: "chain-review", description: "Merge branch", parameters: { action: "branch.merge", chainEntryId, branchName: result2.name } }]
-      )
-    };
-  }
-  if (action === "list") {
-    const branches = await kernelMutation("gitchain.listBranches", { chainEntryId });
-    if (branches.length === 0) {
-      return {
-        content: [{ type: "text", text: `No branches found for chain "${chainEntryId}".` }],
-        structuredContent: success(
-          `No branches for ${chainEntryId}.`,
-          { chainEntryId, branches: [], total: 0 },
-          [{ tool: "chain-review", description: "Create a branch", parameters: { action: "branch.create", chainEntryId } }]
-        )
-      };
-    }
-    const formatted = branches.map((b) => `- **${b.name}** (${b.status}) \u2014 based on v${b.baseVersion}, by ${b.createdBy}`).join("\n");
-    return {
-      content: [{ type: "text", text: `# Branches for ${chainEntryId} (${branches.length})
-
-${formatted}` }],
-      structuredContent: success(
-        `${branches.length} branch(es) for ${chainEntryId}.`,
-        { chainEntryId, total: branches.length }
-      )
-    };
-  }
-  if (action === "merge") {
-    if (!branchName) {
-      return validationResult("A `branchName` is required for merge.");
-    }
-    const result2 = await kernelMutation("gitchain.mergeBranch", { chainEntryId, branchName, strategy, author });
-    return {
-      content: [{
-        type: "text",
-        text: `# Branch Merged
-
-- **Chain:** \`${result2.entryId}\`
-- **Branch:** ${result2.branchName} (now closed)
-- **Version:** v${result2.version}
-- **Strategy:** ${result2.strategy}
-
-Main is now at v${result2.version}. The branch has been closed.`
-      }],
-      structuredContent: success(
-        `Merged branch "${result2.branchName}" into ${result2.entryId} at v${result2.version}.`,
-        { entryId: result2.entryId, branchName: result2.branchName, version: result2.version, versionDisplay: toVersionDisplay(result2.version), strategy: result2.strategy }
-      )
-    };
-  }
-  if (action === "conflicts") {
-    if (!branchName) {
-      return validationResult("A `branchName` is required for conflict check.");
-    }
-    const result2 = await kernelMutation("gitchain.checkConflicts", { chainEntryId, branchName });
-    if (!result2.hasConflicts) {
-      return {
-        content: [{
-          type: "text",
-          text: `# No Conflicts
-
-Branch "${branchName}" on \`${chainEntryId}\` has no conflicts. Safe to merge.`
-        }],
-        structuredContent: success(
-          `No conflicts on branch "${branchName}". Safe to merge.`,
-          { chainEntryId, branchName, hasConflicts: false },
-          [{ tool: "chain-review", description: "Merge branch", parameters: { action: "branch.merge", chainEntryId, branchName } }]
-        )
-      };
-    }
-    const conflictLines = result2.conflicts.map(
-      (c) => `- **${c.linkId}** \u2014 modified by: ${c.branches.map((b) => `${b.branchName} (${b.author})`).join(", ")}`
-    ).join("\n");
-    return {
-      content: [{
-        type: "text",
-        text: `# Conflicts Detected
-
-Branch "${branchName}" conflicts with other branches on these links:
-
-` + conflictLines + `
-
-Resolve conflicts before merging.`
-      }],
-      structuredContent: failure(
-        "CONFLICT",
-        `Branch "${branchName}" has ${result2.conflicts.length} conflict(s).`,
-        "Resolve conflicts on the conflicting links before merging."
-      )
-    };
-  }
-  return unknownAction(action, ["create", "list", "merge", "conflicts"]);
-}
-async function handleChainReview({ action, chainEntryId, commitMessage, versionNumber, linkId, body, commentId, author }) {
-  if (action === "gate") {
-    const gate = await kernelQuery("gitchain.runGate", { chainEntryId, commitMessage });
-    const checkLines = gate.checks.map((c) => `- ${c.pass ? "PASS" : "FAIL"} **${c.name}**: ${c.detail}`).join("\n");
-    const icon = gate.pass ? "PASS" : "BLOCKED";
-    return {
-      content: [{
-        type: "text",
-        text: `# Gate: ${icon}
-
-- **Score:** ${gate.score}%
-- **Threshold:** ${gate.threshold}%
-
-## Checks
-
-${checkLines}`
-      }],
-      structuredContent: success(
-        `Gate ${icon}: ${gate.score}% (threshold ${gate.threshold}%).`,
-        { pass: gate.pass, score: gate.score, threshold: gate.threshold, checks: gate.checks }
-      )
-    };
-  }
-  if (action === "comment") {
-    if (!versionNumber) {
-      return validationResult("A `versionNumber` is required.");
-    }
-    if (!body) {
-      return validationResult("A `body` is required.");
-    }
-    const result2 = await kernelMutation("gitchain.addComment", {
-      chainEntryId,
-      versionNumber,
-      linkId,
-      body,
-      author
-    });
-    return {
-      content: [{
-        type: "text",
-        text: `# Comment Added
-
-- **Chain:** \`${result2.chainEntryId}\`
-- **Version:** v${result2.versionNumber}
-` + (result2.linkId ? `- **Link:** ${result2.linkId}
-` : "") + `- **Body:** ${body.substring(0, 200)}`
-      }],
-      structuredContent: success(
-        `Comment added on ${result2.chainEntryId} v${result2.versionNumber}${result2.linkId ? ` [${result2.linkId}]` : ""}.`,
-        { chainEntryId: result2.chainEntryId, versionNumber: result2.versionNumber, linkId: result2.linkId }
-      )
-    };
-  }
-  if (action === "resolve-comment") {
-    if (!commentId) {
-      return validationResult("A `commentId` is required.");
-    }
-    await kernelMutation("gitchain.resolveComment", { commentId });
-    return successResult("Comment resolved.", `Comment ${commentId} resolved.`, { commentId, resolved: true });
-  }
-  if (action === "list-comments") {
-    const comments = await kernelMutation("gitchain.listComments", {
-      chainEntryId,
-      versionNumber
-    });
-    if (comments.length === 0) {
-      return {
-        content: [{ type: "text", text: `No comments found for chain "${chainEntryId}"${versionNumber ? ` v${versionNumber}` : ""}.` }],
-        structuredContent: success(
-          `No comments for ${chainEntryId}${versionNumber ? ` v${versionNumber}` : ""}.`,
-          { chainEntryId, comments: [], total: 0, unresolved: 0 }
-        )
-      };
-    }
-    const formatted = comments.map((c) => {
-      const date = new Date(c.createdAt).toISOString().replace("T", " ").substring(0, 19);
-      const resolved = c.resolved ? " (RESOLVED)" : "";
-      const link = c.linkId ? ` [${c.linkId}]` : "";
-      return `- **v${c.version}${link}** ${date} by ${c.author}${resolved}: ${c.body.substring(0, 150)}`;
-    }).join("\n");
-    const unresolvedCount = comments.filter((c) => !c.resolved).length;
-    return {
-      content: [{
-        type: "text",
-        text: `# Comments for ${chainEntryId} (${comments.length}, ${unresolvedCount} unresolved)
-
-${formatted}`
-      }],
-      structuredContent: success(
-        `${comments.length} comment(s) for ${chainEntryId}, ${unresolvedCount} unresolved.`,
-        { chainEntryId, total: comments.length, unresolved: unresolvedCount }
-      )
-    };
-  }
-  return unknownAction(action, ["gate", "comment", "resolve-comment", "list-comments"]);
-}
-var CHAIN_ACTIONS = [
-  "create",
-  "get",
-  "list",
-  "edit",
-  "version.commit",
-  "version.list",
-  "version.diff",
-  "version.revert",
-  "version.history"
-];
-var CHAIN_REVIEW_ACTIONS = [
-  "gate",
-  "comment",
-  "resolve-comment",
-  "list-comments",
-  "branch.create",
-  "branch.list",
-  "branch.merge",
-  "branch.conflicts"
-];
-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: 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: 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 = 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: 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: 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: 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,
-  chainEditVariant,
-  chainVersionCommitVariant,
-  chainVersionListVariant,
-  chainVersionDiffVariant,
-  chainVersionRevertVariant,
-  chainVersionHistoryVariant
-]);
-var reviewBase = chainReviewSchema.omit({ action: true });
-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: 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,
-  chainReviewListCommentsVariant,
-  chainBranchCreateVariant,
-  chainBranchListVariant,
-  chainBranchMergeVariant,
-  chainBranchConflictsVariant
-]);
-var CHAIN_ACTION_SPECS = {
-  create: { params: ["title", "chainTypeId", "description", "author", "ownerTeamEntryId", "ownerRoleEntryId"], description: "title is required." },
-  get: { params: ["chainEntryId"], description: "chainEntryId is required." },
-  list: { params: ["chainTypeId", "status"], description: "All params optional." },
-  edit: { params: ["chainEntryId", "linkId", "content", "author"], description: "chainEntryId, linkId, and content are required." },
-  "version.commit": { params: ["chainEntryId", "commitMessage", "author"], description: "chainEntryId and commitMessage are required." },
-  "version.list": { params: ["chainEntryId"], description: "chainEntryId is required." },
-  "version.diff": { params: ["chainEntryId", "versionA", "versionB"], description: "chainEntryId, versionA, and versionB are required." },
-  "version.revert": { params: ["chainEntryId", "toVersion", "author"], description: "chainEntryId and toVersion are required." },
-  "version.history": { params: ["chainEntryId"], description: "chainEntryId is required." }
-};
-var CHAIN_REVIEW_ACTION_SPECS = {
-  gate: { params: ["chainEntryId", "commitMessage"], description: "chainEntryId is required." },
-  comment: { params: ["chainEntryId", "versionNumber", "linkId", "body", "author"], description: "chainEntryId, versionNumber, and body are required." },
-  "resolve-comment": { params: ["commentId"], description: "commentId is required." },
-  "list-comments": { params: ["chainEntryId", "versionNumber"], description: "chainEntryId is required." },
-  "branch.create": { params: ["chainEntryId", "branchName", "author"], description: "chainEntryId is required." },
-  "branch.list": { params: ["chainEntryId"], description: "chainEntryId is required." },
-  "branch.merge": { params: ["chainEntryId", "branchName", "strategy", "author"], description: "chainEntryId and branchName are required." },
-  "branch.conflicts": { params: ["chainEntryId", "branchName"], description: "chainEntryId and branchName are required." }
-};
-function registerGitChainTools(server) {
-  const chainHandlers = {
-    create: (data) => handleChainCrud({ ...data, action: "create" }),
-    get: (data) => handleChainCrud({ ...data, action: "get" }),
-    list: (data) => handleChainCrud({ ...data, action: "list" }),
-    edit: (data) => handleChainCrud({ ...data, action: "edit" }),
-    "version.commit": (data) => handleChainVersion({ ...data, action: "commit" }),
-    "version.list": (data) => handleChainVersion({ ...data, action: "list" }),
-    "version.diff": (data) => handleChainVersion({ ...data, action: "diff" }),
-    "version.revert": (data) => handleChainVersion({ ...data, action: "revert" }),
-    "version.history": (data) => handleChainVersion({ ...data, action: "history" })
-  };
-  const chainReviewHandlers = {
-    gate: (data) => handleChainReview({ ...data, action: "gate" }),
-    comment: (data) => handleChainReview({ ...data, action: "comment" }),
-    "resolve-comment": (data) => handleChainReview({ ...data, action: "resolve-comment" }),
-    "list-comments": (data) => handleChainReview({ ...data, action: "list-comments" }),
-    "branch.create": (data) => handleChainBranch({ ...data, action: "create" }),
-    "branch.list": (data) => handleChainBranch({ ...data, action: "list" }),
-    "branch.merge": (data) => handleChainBranch({ ...data, action: "merge" }),
-    "branch.conflicts": (data) => handleChainBranch({ ...data, action: "conflicts" })
-  };
-  server.registerTool(
-    "chain",
-    {
-      title: "Chain",
-      description: "Manage processes \u2014 CRUD and versioning. Processes are versioned knowledge artifacts that follow a process template (e.g. Strategy Coherence: Problem \u2192 Insight \u2192 Choice \u2192 Action \u2192 Outcome). Module-gated (PB_MODULES=gitchain).\n\n- **create/get/list/edit**: process CRUD.\n- **version.commit/version.list/version.diff/version.revert/version.history**: versioning (absorbs `chain-version`).\n\nBranching and review live on the sibling `chain-review` tool.",
-      inputSchema: chainCompoundSchema,
-      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
-    },
-    thinWrapper(async (args) => {
-      const parsed = parseOrFail(chainCompoundSchema, args);
-      if (!parsed.ok) return parsed.result;
-      const { action } = parsed.data;
-      return runWithToolContext(
-        { tool: "chain", action },
-        () => dispatchDiscriminated("chain", chainActionUnion, parsed.data, CHAIN_ACTION_SPECS, chainHandlers)
-      );
-    })
-  );
-  server.registerTool(
-    "chain-review",
-    {
-      title: "Chain Review",
-      description: "Review process quality and manage branches. Module-gated (PB_MODULES=gitchain).\n\n- **gate**: run the coherence gate \u2014 checks coherence score >= 70%, all links filled, commit message convention.\n- **comment/resolve-comment/list-comments**: manage comments on process versions.\n- **branch.create/branch.list/branch.merge/branch.conflicts**: branching (absorbs `chain-branch`).\n\nProcess CRUD and versioning live on the sibling `chain` tool.",
-      inputSchema: chainReviewCompoundSchema,
-      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
-    },
-    thinWrapper(async (args) => {
-      const parsed = parseOrFail(chainReviewCompoundSchema, args);
-      if (!parsed.ok) return parsed.result;
-      const { action } = parsed.data;
-      return runWithToolContext(
-        { tool: "chain-review", action },
-        () => dispatchDiscriminated("chain-review", chainReviewActionUnion, parsed.data, CHAIN_REVIEW_ACTION_SPECS, chainReviewHandlers)
-      );
-    })
-  );
-}
-
 // src/tools/workspace.ts
-import { z as z30 } from "zod/v3";
+import { z as z29 } from "zod/v3";
 
 // src/tools/health.ts
-import { z as z28 } from "zod/v3";
+import { z as z27 } from "zod/v3";
 
 // src/lib/auditView.ts
 async function buildTenantAuditView(limit) {
@@ -13528,61 +12803,61 @@ ${logLines.join("\n")}${seamSummaryText}` }],
   };
 }
 var HEALTH_ACTIONS = ["check", "whoami", "status", "audit", "self-test"];
-var healthSchema = z28.object({
-  action: z28.enum(HEALTH_ACTIONS).describe(
+var healthSchema = z27.object({
+  action: z27.enum(HEALTH_ACTIONS).describe(
     "'check': connectivity and workspace stats. 'whoami': session identity. 'status': workspace readiness. 'audit': session audit log. 'self-test': validate all tool schemas."
   ),
-  limit: z28.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
+  limit: z27.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
 });
-var healthCheckOutputSchema = z28.object({
-  healthy: z28.boolean(),
-  collections: z28.number(),
-  entries: z28.number(),
-  latencyMs: z28.number(),
-  workspace: z28.string()
+var healthCheckOutputSchema = z27.object({
+  healthy: z27.boolean(),
+  collections: z27.number(),
+  entries: z27.number(),
+  latencyMs: z27.number(),
+  workspace: z27.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 = z27.object({
+  reviewed: z27.number(),
+  agreements: z27.number(),
+  disagreements: z27.number(),
+  abstentions: z27.number(),
+  agreementRate: z27.number(),
+  flags: z27.array(z27.object({ collection: z27.string(), count: z27.number(), suggestedCollection: z27.string() }))
 });
-var healthStatusOutputSchema = z28.object({
-  stage: z28.enum(["blank", "seeded", "grounded", "connected"]).optional().default("seeded"),
-  sampleTruncated: z28.boolean().nullable().optional(),
-  activeEntries: z28.number(),
-  totalRelations: z28.number(),
-  orphanedEntries: z28.number(),
-  checks: z28.array(z28.object({ label: z28.string(), passed: z28.boolean(), current: z28.number(), required: z28.number() })),
-  gaps: z28.array(z28.object({ id: z28.string(), label: z28.string(), guidance: z28.string() })),
+var healthStatusOutputSchema = z27.object({
+  stage: z27.enum(["blank", "seeded", "grounded", "connected"]).optional().default("seeded"),
+  sampleTruncated: z27.boolean().nullable().optional(),
+  activeEntries: z27.number(),
+  totalRelations: z27.number(),
+  orphanedEntries: z27.number(),
+  checks: z27.array(z27.object({ label: z27.string(), passed: z27.boolean(), current: z27.number(), required: z27.number() })),
+  gaps: z27.array(z27.object({ id: z27.string(), label: z27.string(), guidance: z27.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 = z27.object({
+  totalCalls: z27.number(),
+  calls: z27.array(z27.object({
+    tool: z27.string(),
+    action: z27.string().optional(),
+    timestamp: z27.string(),
+    durationMs: z27.number().optional()
   }))
 });
-var healthWhoamiOutputSchema = z28.object({
-  workspaceId: z28.string(),
-  workspaceName: z28.string(),
-  scope: z28.string(),
-  sessionId: z28.union([z28.string(), z28.null()]),
-  oriented: z28.boolean()
+var healthWhoamiOutputSchema = z27.object({
+  workspaceId: z27.string(),
+  workspaceName: z27.string(),
+  scope: z27.string(),
+  sessionId: z27.union([z27.string(), z27.null()]),
+  oriented: z27.boolean()
 });
-var selfTestOutputSchema = 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 = z27.object({
+  passed: z27.number(),
+  failed: z27.number(),
+  total: z27.number(),
+  results: z27.array(z27.object({
+    tool: z27.string(),
+    valid: z27.boolean(),
+    error: z27.string().optional()
   }))
 });
 function handleSelfTest(server) {
@@ -13633,9 +12908,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 z28 } from "zod/v3";
+var usageSummarySchema = z28.object({
+  periodDays: z28.number().min(1).max(90).optional().describe("Number of days to look back (default 30, max 90)")
 });
 async function handleUsageSummary(periodDays) {
   const ws = await getWorkspaceContext();
@@ -13807,35 +13082,35 @@ var WORKSPACE_ACTIONS = [
   "proposals-respond",
   "proposals-count"
 ];
-var workspaceSchema = z30.object({
-  action: z30.enum(WORKSPACE_ACTIONS).describe(
+var workspaceSchema = z29.object({
+  action: z29.enum(WORKSPACE_ACTIONS).describe(
     "'check': connectivity and workspace stats (absorbs health action=check). 'whoami': session identity (absorbs health action=whoami). 'status': workspace readiness (absorbs health action=status). 'audit': session audit log (absorbs health action=audit). 'self-test': validate all tool schemas (absorbs health action=self-test). 'usage': LLM usage and cost summary (absorbs get-usage-summary). 'proposals-list': list open consent proposals (absorbs governance-proposals action=list). 'proposals-respond': approve/reject a consent proposal (absorbs governance-proposals action=respond). 'proposals-count': count open consent proposals (absorbs governance-proposals action=count)."
   ),
-  limit: 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: z29.number().min(1).max(50).optional().describe("For 'audit': how many recent calls to show (max 50, default 20)."),
+  periodDays: z29.number().min(1).max(90).optional().describe("For 'usage': number of days to look back (default 30, max 90)."),
+  status: z29.enum(["open", "approved", "objected", "expired"]).optional().describe("For 'proposals-list': filter by status (default: open)."),
+  proposalId: z29.string().max(200).optional().describe("For 'proposals-respond': proposal ID."),
+  verdict: z29.enum(["approve", "reject"]).optional().describe("For 'proposals-respond': approve or reject."),
+  reason: z29.string().max(2e3).optional().describe("For 'proposals-respond': reason for the verdict (required when rejecting).")
 });
-var workspaceCheckVariant = 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 = z29.object({ action: z29.literal("check") });
+var workspaceWhoamiVariant = z29.object({ action: z29.literal("whoami") });
+var workspaceStatusVariant = z29.object({ action: z29.literal("status") });
+var workspaceAuditVariant = z29.object({ action: z29.literal("audit"), limit: z29.number().min(1).max(50).optional().default(20) });
+var workspaceSelfTestVariant = z29.object({ action: z29.literal("self-test") });
+var workspaceUsageVariant = z29.object({ action: z29.literal("usage"), periodDays: z29.number().min(1).max(90).optional() });
+var workspaceProposalsListVariant = z29.object({
+  action: z29.literal("proposals-list"),
+  status: z29.enum(["open", "approved", "objected", "expired"]).optional()
 });
-var workspaceProposalsRespondVariant = 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 = z29.object({
+  action: z29.literal("proposals-respond"),
+  proposalId: z29.string().max(200),
+  verdict: z29.enum(["approve", "reject"]),
+  reason: z29.string().max(2e3).optional()
 });
-var workspaceProposalsCountVariant = z30.object({ action: z30.literal("proposals-count") });
-var workspaceActionUnion = z30.discriminatedUnion("action", [
+var workspaceProposalsCountVariant = z29.object({ action: z29.literal("proposals-count") });
+var workspaceActionUnion = z29.discriminatedUnion("action", [
   workspaceCheckVariant,
   workspaceWhoamiVariant,
   workspaceStatusVariant,
@@ -13891,7 +13166,7 @@ function registerWorkspaceTools(server) {
 }
 
 // src/tools/feedback.ts
-import { z as z31 } from "zod/v3";
+import { z as z30 } from "zod/v3";
 
 // src/lib/productFeedbackConstants.ts
 var PRODUCT_FEEDBACK_CATEGORIES = ["bug", "friction", "idea", "praise", "other"];
@@ -13902,9 +13177,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 = z30.enum(PRODUCT_FEEDBACK_CATEGORIES);
+var status = z30.enum(PRODUCT_FEEDBACK_STATUSES);
+var vendorStatus = z30.enum(VENDOR_SETTABLE_STATUSES);
 var GATEWAY_MAX_STRING_BYTES = 10240;
 var utf8Bytes = (value) => new TextEncoder().encode(value).length;
 var fitsGatewayBytes = (value) => utf8Bytes(value) <= GATEWAY_MAX_STRING_BYTES;
@@ -13913,32 +13188,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 = z30.object({
+  action: z30.enum(actions).describe("submit requires message; list returns your own workspace's feedback (all statuses); queue is the vendor triage queue (system admins only) and accepts filters; note requires feedbackId+note; group requires feedbackIds+groupId (null clears); status requires feedbackId+status."),
+  message: z30.string().max(1e4).optional().describe("Required for submit: the product feedback text (max 10,000 chars and 10,240 UTF-8 bytes)."),
   category: category.optional().describe("Submit/queue category; submit defaults to other."),
-  command: 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: z30.string().max(1e3).optional().describe("Optional submit command context; argument values are scrubbed server-side."),
+  route: z30.string().max(500).optional().describe("Optional submit route context."),
+  client: z30.string().max(100).optional().describe("Optional submit client label."),
+  feedbackId: z30.string().max(200).optional().describe("Required for note/status: target feedback ID."),
+  feedbackIds: z30.array(z30.string().max(200)).max(100).optional().describe("Required for group: 1\u2013100 target feedback IDs."),
+  note: z30.string().max(4e3).optional().describe("Required for note: replacement triage note (max 10,240 UTF-8 bytes)."),
   status: status.optional().describe("list/queue filter (any status, including 'screening'); the status action's required target value excludes 'screening' (system-only)."),
-  groupId: 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: z30.string().min(1).max(200).nullable().optional().describe("Group filter, or required group destination; null explicitly clears grouping."),
+  workspaceId: z30.string().max(200).optional().describe("Queue-only filter (vendor cross-workspace triage); omitted means all workspaces. Has no effect on list \u2014 your own workspace is always injected server-side."),
+  since: z30.number().optional().describe("Queue-only lower createdAt window bound (inclusive) in epoch milliseconds."),
+  before: z30.number().optional().describe("Queue-only upper createdAt window bound (exclusive) in epoch milliseconds. A time-window FILTER, not the pager \u2014 use cursor to page."),
+  limit: z30.number().int().min(1).max(100).optional().describe("list/queue row limit, default 50, maximum 100."),
+  cursor: z30.string().max(2e3).optional().describe("Opaque pagination cursor from a previous list/queue response (continueCursor); omit for the first page."),
+  full: z30.boolean().optional().describe(`list/queue only: return untruncated messages; allowed only when limit <= ${FULL_MESSAGE_MAX_LIMIT}.`)
 });
-var union = 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 = z30.discriminatedUnion("action", [
+  z30.object({ action: z30.literal("submit"), message: z30.string().min(1).max(1e4).refine(fitsGatewayBytes, byteLimitMessage("message")), category: category.optional(), command: z30.string().max(1e3).optional(), route: z30.string().max(500).optional(), client: z30.string().max(100).optional() }),
+  z30.object({ action: z30.literal("list"), status: status.optional(), limit: z30.number().int().min(1).max(100).optional(), cursor: z30.string().max(2e3).optional(), full: z30.boolean().optional() }),
+  z30.object({ action: z30.literal("queue"), status: status.optional(), category: category.optional(), groupId: z30.string().min(1).max(200).optional(), workspaceId: z30.string().max(200).optional(), since: z30.number().optional(), before: z30.number().optional(), limit: z30.number().int().min(1).max(100).optional(), cursor: z30.string().max(2e3).optional(), full: z30.boolean().optional() }),
+  z30.object({ action: z30.literal("note"), feedbackId: z30.string().min(1).max(200), note: z30.string().max(4e3).refine(fitsGatewayBytes, byteLimitMessage("note")) }),
+  z30.object({ action: z30.literal("group"), feedbackIds: z30.array(z30.string().min(1).max(200)).min(1).max(100), groupId: z30.string().min(1).max(200).nullable() }),
+  z30.object({ action: z30.literal("status"), feedbackId: z30.string().min(1).max(200), status: vendorStatus })
 ]);
 var specs = {
   submit: { params: ["message", "category", "command", "route", "client"], description: "message is required; category defaults to other." },
@@ -14065,34 +13340,34 @@ function registerFeedbackTool(server) {
 }
 
 // src/tools/shape.ts
-import { z as z32 } from "zod/v3";
+import { z as z31 } from "zod/v3";
 var SHAPE_ACTIONS = ["list", "show", "agree", "dismiss"];
 var LIST_DISPOSITIONS = ["pending", "agreed", "dismissed", "expired"];
 var LIST_OUTCOMES = ["not_candidate", "atomic", "compound", "unavailable"];
-var shapeSchema = z32.object({
-  action: z32.enum(SHAPE_ACTIONS).describe(
+var shapeSchema = z31.object({
+  action: z31.enum(SHAPE_ACTIONS).describe(
     "'list': list shape advisories for this workspace, latest per subject. 'show': show one shape advisory by id. 'agree': agree with a compound advisory's split verdict. 'dismiss': dismiss a compound advisory's split verdict."
   ),
-  disposition: z32.enum(LIST_DISPOSITIONS).optional().describe(
+  disposition: z31.enum(LIST_DISPOSITIONS).optional().describe(
     "For 'list': filter by disposition. Omitting both disposition and outcome defaults to the actionable set (disposition:pending, outcome:compound)."
   ),
-  outcome: z32.enum(LIST_OUTCOMES).optional().describe(
+  outcome: z31.enum(LIST_OUTCOMES).optional().describe(
     "For 'list': filter by outcome. Omitting both disposition and outcome defaults to the actionable set (disposition:pending, outcome:compound)."
   ),
-  limit: 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: z31.number().min(1).max(200).optional().describe("For 'list': max rows (default 50, max 200)."),
+  rowId: z31.string().max(200).optional().describe("For 'show'/'agree'/'dismiss': the advisory row id."),
+  reason: z31.string().max(1e3).optional().describe("For 'agree'/'dismiss': optional reason (capped at 1000 chars).")
 });
-var shapeListVariant = 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 = z31.object({
+  action: z31.literal("list"),
+  disposition: z31.enum(LIST_DISPOSITIONS).optional(),
+  outcome: z31.enum(LIST_OUTCOMES).optional(),
+  limit: z31.number().min(1).max(200).optional()
 });
-var shapeShowVariant = 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 = z31.object({ action: z31.literal("show"), rowId: z31.string().max(200) });
+var shapeAgreeVariant = z31.object({ action: z31.literal("agree"), rowId: z31.string().max(200), reason: z31.string().max(1e3).optional() });
+var shapeDismissVariant = z31.object({ action: z31.literal("dismiss"), rowId: z31.string().max(200), reason: z31.string().max(1e3).optional() });
+var shapeActionUnion = z31.discriminatedUnion("action", [
   shapeListVariant,
   shapeShowVariant,
   shapeAgreeVariant,
@@ -14239,31 +13514,31 @@ function registerShapeTools(server) {
 }
 
 // src/tools/question.ts
-import { z as z33 } from "zod/v3";
+import { z as z32 } from "zod/v3";
 var QUESTION_ACTIONS = ["create", "adopt", "assign", "snooze", "decline", "answer", "force-close", "list"];
-var questionSchema = z33.object({
-  action: z33.enum(QUESTION_ACTIONS).describe(
+var questionSchema = z32.object({
+  action: z32.enum(QUESTION_ACTIONS).describe(
     "'create': create a new routed question from text (domains come from `pb question --help` / this tool's own refusal \u2014 never hardcode a slug). 'adopt': adopt attaches routing to an existing tension or repairs a facet-less question \u2014 create is the birth path. Without adopt, a tension captured via `pb capture \"TEN: ...\"` stays invisible to routing forever. 'assign': confirm ('take it', omit toRole/toPerson) or reassign (supply toRole and/or toPerson) ownership. 'snooze': defer a routed/escalated question (max 2, then it escalates). 'decline': pass on a suggested question, or (as owner/lead) decline an owned one \u2014 reason required. 'answer': close the loop \u2014 creates the answering entry itself unless --entry is given. 'force-close': Team-Lead-only escape hatch \u2014 reason required. 'list': the ack-gate read model \u2014 what you owe (or, with mine:true, every question you asked, including closed ones)."
   ),
-  entryId: z33.string().max(200).optional().describe("Target question's id (human TEN-nnn form or a raw entry id). Required for every action except 'create'/'list'."),
-  text: z33.string().max(5e3).optional().describe("'create': the question text. 'answer': the answer text (mutually exclusive with answerEntryId, max 2000 chars)."),
-  domain: z33.string().max(200).optional().describe("'create'/'adopt': the domain slug (see this tool's refusal for the live list)."),
-  blocks: z33.array(z33.string().max(200)).max(50).optional().describe("'create'/'adopt': entry ids this question is blocking (repeatable)."),
-  toRole: z33.string().max(200).optional().describe("'assign': reassign to this role (human ROL-nnn form or a raw entry id)."),
-  toPerson: z33.string().max(200).optional().describe("'assign': reassign to this person (a raw person id)."),
-  reason: z33.string().max(2e3).optional().describe("'decline'/'force-close': required reason."),
-  answerEntryId: z33.string().max(200).optional().describe("'answer': point at an already-written entry instead of supplying text (mutually exclusive with text)."),
-  mine: z33.boolean().optional().describe("'list': true for arm C (every question YOU asked, every status). Omit/false for the ack-gate view (what you owe).")
+  entryId: z32.string().max(200).optional().describe("Target question's id (human TEN-nnn form or a raw entry id). Required for every action except 'create'/'list'."),
+  text: z32.string().max(5e3).optional().describe("'create': the question text. 'answer': the answer text (mutually exclusive with answerEntryId, max 2000 chars)."),
+  domain: z32.string().max(200).optional().describe("'create'/'adopt': the domain slug (see this tool's refusal for the live list)."),
+  blocks: z32.array(z32.string().max(200)).max(50).optional().describe("'create'/'adopt': entry ids this question is blocking (repeatable)."),
+  toRole: z32.string().max(200).optional().describe("'assign': reassign to this role (human ROL-nnn form or a raw entry id)."),
+  toPerson: z32.string().max(200).optional().describe("'assign': reassign to this person (a raw person id)."),
+  reason: z32.string().max(2e3).optional().describe("'decline'/'force-close': required reason."),
+  answerEntryId: z32.string().max(200).optional().describe("'answer': point at an already-written entry instead of supplying text (mutually exclusive with text)."),
+  mine: z32.boolean().optional().describe("'list': true for arm C (every question YOU asked, every status). Omit/false for the ack-gate view (what you owe).")
 });
-var createVariant = z33.object({ action: z33.literal("create"), text: z33.string().min(1).max(5e3), domain: z33.string().max(200).optional(), blocks: z33.array(z33.string().max(200)).max(50).optional() });
-var adoptVariant = z33.object({ action: z33.literal("adopt"), entryId: z33.string().max(200), domain: z33.string().max(200).optional(), blocks: z33.array(z33.string().max(200)).max(50).optional() });
-var assignVariant = z33.object({ action: z33.literal("assign"), entryId: z33.string().max(200), toRole: z33.string().max(200).optional(), toPerson: z33.string().max(200).optional() });
-var snoozeVariant = z33.object({ action: z33.literal("snooze"), entryId: z33.string().max(200) });
-var declineVariant = z33.object({ action: z33.literal("decline"), entryId: z33.string().max(200), reason: z33.string().min(1).max(2e3) });
-var answerVariant = z33.object({ action: z33.literal("answer"), entryId: z33.string().max(200), text: z33.string().max(2e3).optional(), answerEntryId: z33.string().max(200).optional() });
-var forceCloseVariant = z33.object({ action: z33.literal("force-close"), entryId: z33.string().max(200), reason: z33.string().min(1).max(2e3) });
-var listVariant = z33.object({ action: z33.literal("list"), mine: z33.boolean().optional() });
-var questionActionUnion = z33.discriminatedUnion("action", [
+var createVariant = z32.object({ action: z32.literal("create"), text: z32.string().min(1).max(5e3), domain: z32.string().max(200).optional(), blocks: z32.array(z32.string().max(200)).max(50).optional() });
+var adoptVariant = z32.object({ action: z32.literal("adopt"), entryId: z32.string().max(200), domain: z32.string().max(200).optional(), blocks: z32.array(z32.string().max(200)).max(50).optional() });
+var assignVariant = z32.object({ action: z32.literal("assign"), entryId: z32.string().max(200), toRole: z32.string().max(200).optional(), toPerson: z32.string().max(200).optional() });
+var snoozeVariant = z32.object({ action: z32.literal("snooze"), entryId: z32.string().max(200) });
+var declineVariant = z32.object({ action: z32.literal("decline"), entryId: z32.string().max(200), reason: z32.string().min(1).max(2e3) });
+var answerVariant = z32.object({ action: z32.literal("answer"), entryId: z32.string().max(200), text: z32.string().max(2e3).optional(), answerEntryId: z32.string().max(200).optional() });
+var forceCloseVariant = z32.object({ action: z32.literal("force-close"), entryId: z32.string().max(200), reason: z32.string().min(1).max(2e3) });
+var listVariant = z32.object({ action: z32.literal("list"), mine: z32.boolean().optional() });
+var questionActionUnion = z32.discriminatedUnion("action", [
   createVariant,
   adoptVariant,
   assignVariant,
@@ -14506,23 +13781,23 @@ function registerQuestionTools(server) {
 }
 
 // src/tools/role.ts
-import { z as z34 } from "zod/v3";
+import { z as z33 } from "zod/v3";
 var ROLE_ACTIONS = ["accountable"];
-var roleSchema = z34.object({
-  action: z34.enum(ROLE_ACTIONS).describe("'accountable': what this role owns (explicit), reports on (reporting), and \u2014 not yet computed \u2014 inherits via Team-Lead vacancy coverage."),
-  roleId: z34.string().max(200).optional().describe("The role, by the human chain id `chain.getEntry` or `pb get` would print for it, or a raw entry id. Required for 'accountable'."),
-  canonicalKey: z34.string().max(200).optional().describe("'accountable': narrow to one kind (e.g. objective, key_result, tension)."),
-  limit: z34.number().int().positive().max(200).optional().describe("'accountable': max explicit-list rows per page (default and maximum 200)."),
-  cursor: z34.number().optional().describe("'accountable': continue the explicit list from an earlier truncated page's nextCursor.")
+var roleSchema = z33.object({
+  action: z33.enum(ROLE_ACTIONS).describe("'accountable': what this role owns (explicit), reports on (reporting), and \u2014 not yet computed \u2014 inherits via Team-Lead vacancy coverage."),
+  roleId: z33.string().max(200).optional().describe("The role, by the human chain id `chain.getEntry` or `pb get` would print for it, or a raw entry id. Required for 'accountable'."),
+  canonicalKey: z33.string().max(200).optional().describe("'accountable': narrow to one kind (e.g. objective, key_result, tension)."),
+  limit: z33.number().int().positive().max(200).optional().describe("'accountable': max explicit-list rows per page (default and maximum 200)."),
+  cursor: z33.number().optional().describe("'accountable': continue the explicit list from an earlier truncated page's nextCursor.")
 });
-var accountableVariant = z34.object({
-  action: z34.literal("accountable"),
-  roleId: z34.string().max(200),
-  canonicalKey: z34.string().max(200).optional(),
-  limit: z34.number().int().positive().max(200).optional(),
-  cursor: z34.number().optional()
+var accountableVariant = z33.object({
+  action: z33.literal("accountable"),
+  roleId: z33.string().max(200),
+  canonicalKey: z33.string().max(200).optional(),
+  limit: z33.number().int().positive().max(200).optional(),
+  cursor: z33.number().optional()
 });
-var roleActionUnion = z34.discriminatedUnion("action", [accountableVariant]);
+var roleActionUnion = z33.discriminatedUnion("action", [accountableVariant]);
 var ROLE_ACTION_SPECS = {
   accountable: { params: ["roleId", "canonicalKey", "limit", "cursor"], description: "roleId is required; canonicalKey/limit/cursor are optional." }
 };
@@ -14595,49 +13870,49 @@ function registerRoleTools(server) {
 }
 
 // src/tools/outcome.ts
-import { z as z35 } from "zod/v3";
+import { z as z34 } from "zod/v3";
 var OUTCOME_ACTIONS = ["record", "list", "show"];
 var READING_KINDS = ["measurement", "estimate", "correction"];
-var outcomeSchema = z35.object({
-  action: z35.enum(OUTCOME_ACTIONS).describe(
+var outcomeSchema = z34.object({
+  action: z34.enum(OUTCOME_ACTIONS).describe(
     "'record': record a reading (evidence, not a verdict). 'list': list readings, newest first. 'show': the derived view \u2014 current, progress, pace, staleness, recorded completion."
   ),
-  entryId: z35.string().max(200).optional().describe("The key result (or other outcome-bearing) entry, by its chain id. Required for all three actions."),
+  entryId: z34.string().max(200).optional().describe("The key result (or other outcome-bearing) entry, by its chain id. Required for all three actions."),
   // PR #858 review round 3 (Codex P2, PRRT_kwDORS4ils6gXHj9): a JSON number that overflows to
   // `Infinity` (e.g. `1e400`) parses fine in JS and passes a plain `z.number()`, but
   // `callGateway()` serializes it with `JSON.stringify`, which turns `Infinity` into `null` —
   // the backend's `v.number()` validator then rejects a call this tool's own schema accepted.
   // `.finite()` rejects it here, matching the explicit finite-value checks the CLI/other outcome
   // entry surfaces already use.
-  value: z35.number().finite().optional().describe("'record': the measured value. Required for 'record'."),
-  valueText: z35.string().max(500).optional().describe("'record': verbatim as-reported form when the source was not clean, e.g. '~62%'. Display only."),
-  asOf: z35.string().max(64).optional().describe("'record': when the world was in this state, as a parseable date (default: now). Back-dating a backfill is legitimate \u2014 it shows up as asOf earlier than recordedAt."),
-  kind: z35.enum(READING_KINDS).optional().describe("'record': measurement | estimate | correction (default: measurement)."),
-  correctsReadingId: z35.string().max(200).optional().describe("'record': required with kind='correction' \u2014 the reading id this replaces. Refused if that row is already superseded."),
-  recordedByRoleId: z35.string().max(200).optional().describe("'record': the accountable role (default: the entry's reporterRoleId, then its owning role)."),
-  note: z35.string().max(2e3).optional().describe("'record': free-text note recorded with the reading."),
-  source: z35.string().max(500).optional().describe("'record': where the number came from \u2014 a dashboard name, a query, a URL."),
-  limit: z35.number().int().positive().max(200).optional().describe("'list': max rows to return (default and maximum 200).")
+  value: z34.number().finite().optional().describe("'record': the measured value. Required for 'record'."),
+  valueText: z34.string().max(500).optional().describe("'record': verbatim as-reported form when the source was not clean, e.g. '~62%'. Display only."),
+  asOf: z34.string().max(64).optional().describe("'record': when the world was in this state, as a parseable date (default: now). Back-dating a backfill is legitimate \u2014 it shows up as asOf earlier than recordedAt."),
+  kind: z34.enum(READING_KINDS).optional().describe("'record': measurement | estimate | correction (default: measurement)."),
+  correctsReadingId: z34.string().max(200).optional().describe("'record': required with kind='correction' \u2014 the reading id this replaces. Refused if that row is already superseded."),
+  recordedByRoleId: z34.string().max(200).optional().describe("'record': the accountable role (default: the entry's reporterRoleId, then its owning role)."),
+  note: z34.string().max(2e3).optional().describe("'record': free-text note recorded with the reading."),
+  source: z34.string().max(500).optional().describe("'record': where the number came from \u2014 a dashboard name, a query, a URL."),
+  limit: z34.number().int().positive().max(200).optional().describe("'list': max rows to return (default and maximum 200).")
 });
-var recordVariant = z35.object({
-  action: z35.literal("record"),
-  entryId: z35.string().max(200),
-  value: z35.number().finite(),
-  valueText: z35.string().max(500).optional(),
-  asOf: z35.string().max(64).optional(),
-  kind: z35.enum(READING_KINDS).optional(),
-  correctsReadingId: z35.string().max(200).optional(),
-  recordedByRoleId: z35.string().max(200).optional(),
-  note: z35.string().max(2e3).optional(),
-  source: z35.string().max(500).optional()
+var recordVariant = z34.object({
+  action: z34.literal("record"),
+  entryId: z34.string().max(200),
+  value: z34.number().finite(),
+  valueText: z34.string().max(500).optional(),
+  asOf: z34.string().max(64).optional(),
+  kind: z34.enum(READING_KINDS).optional(),
+  correctsReadingId: z34.string().max(200).optional(),
+  recordedByRoleId: z34.string().max(200).optional(),
+  note: z34.string().max(2e3).optional(),
+  source: z34.string().max(500).optional()
 });
-var listVariant2 = z35.object({
-  action: z35.literal("list"),
-  entryId: z35.string().max(200),
-  limit: z35.number().int().positive().max(200).optional()
+var listVariant2 = z34.object({
+  action: z34.literal("list"),
+  entryId: z34.string().max(200),
+  limit: z34.number().int().positive().max(200).optional()
 });
-var showVariant = z35.object({ action: z35.literal("show"), entryId: z35.string().max(200) });
-var outcomeActionUnion = z35.discriminatedUnion("action", [recordVariant, listVariant2, showVariant]);
+var showVariant = z34.object({ action: z34.literal("show"), entryId: z34.string().max(200) });
+var outcomeActionUnion = z34.discriminatedUnion("action", [recordVariant, listVariant2, showVariant]);
 var OUTCOME_ACTION_SPECS = {
   record: {
     params: ["entryId", "value", "valueText", "asOf", "kind", "correctsReadingId", "recordedByRoleId", "note", "source"],
@@ -14843,7 +14118,7 @@ import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 var DATA_HANDLING_SECTION = "### How PB Handles Your Data\n- **The reply is the source of truth**: every reply carries `ok`; on failure it carries `code` and guidance. Read the reply, never an expectation.\n- **Empty-workspace safe**: the orientation resource and this cheatsheet render on a workspace with no entries and no collections.\n- **Workspace-agnostic**: PB is one product used by many teams. Nothing in these instructions is specific to your workspace; your own principles, standards and rules arrive through `productbrain://orientation`.\n- **Served, not installed**: these instructions, `productbrain://orientation` and `productbrain://agent-cheatsheet` are served over MCP.";
 var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
 
-## Core Tools (Serves 15 default compound tools; 2 more (chain, chain-review) behind PB_MODULES=gitchain)
+## Core Tools (Serves 15 compound tools, always)
 | Tool | Purpose | Actions |
 |---|---|---|
 | \`orient\` | Workspace context, governance, active work packages, session start | \`action\`: start, task, record-activation |
@@ -15349,12 +14624,12 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 }
 
 // src/prompts/index.ts
-import { z as z36 } from "zod/v3";
+import { z as z35 } 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: z36.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z35.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);
@@ -15407,7 +14682,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: z36.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z35.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(
@@ -15443,7 +14718,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: z36.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z35.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);
@@ -15481,8 +14756,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: z36.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
-      domain: z36.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z35.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z35.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" });
@@ -15591,9 +14866,6 @@ function createProductBrainServer() {
     { name: "Product Brain", version: SERVER_VERSION },
     { capabilities: { logging: {} }, instructions: INSTRUCTIONS }
   );
-  const enabledModules = new Set(
-    (process.env.PB_MODULES ?? "core").split(",").map((m) => m.trim().toLowerCase())
-  );
   registerSessionTools(server);
   registerEntriesTools(server);
   registerRelationsTools(server);
@@ -15609,7 +14881,6 @@ function createProductBrainServer() {
   registerQuestionTools(server);
   registerRoleTools(server);
   registerOutcomeTools(server);
-  if (enabledModules.has("gitchain")) registerGitChainTools(server);
   registerResources(server);
   registerPrompts(server);
   return server;
@@ -15645,4 +14916,4 @@ export {
   createProductBrainServer,
   initFeatureFlags
 };
-//# sourceMappingURL=chunk-GBEBTAN6.js.map
+//# sourceMappingURL=chunk-NKO44SHW.js.map