@productbrain/mcp 0.0.1-beta.1 → 0.0.1-beta.3

package/dist/index.js

@@ -2,8 +2,8 @@
 import "./chunk-DGUM43GV.js";
 
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -22,7 +22,7 @@ function log(msg) {
   }
 }
 function initAnalytics() {
-  const apiKey = process.env.POSTHOG_MCP_KEY || "phc_T09qliVxaxpdK8jL3HhSBhedzgxw5N4G4yG4x01jrxj";
+  const apiKey = process.env.POSTHOG_MCP_KEY || "";
   if (!apiKey) {
     log("[MCP-ANALYTICS] No PostHog key \u2014 tracking disabled (set SYNERGYOS_POSTHOG_KEY at build time for publish)\n");
     return;
@@ -79,7 +79,7 @@ async function shutdownAnalytics() {
 }
 
 // src/client.ts
-var DEFAULT_CLOUD_URL = "https://earnest-sheep-635.convex.site";
+var DEFAULT_CLOUD_URL = "https://trustworthy-kangaroo-277.convex.site";
 var cachedWorkspaceId = null;
 var cloudMode = false;
 var AUDIT_BUFFER_SIZE = 50;
@@ -388,29 +388,32 @@ ${msg}
     "update-entry",
     {
       title: "Update Entry",
-      description: "Update an existing entry by its human-readable ID. Only provide the fields you want to change \u2014 data fields are merged with existing values. Use get-entry first to see current values. SOS-020: Cannot update tension status via MCP \u2014 process decides (use SynergyOS UI after approval).",
+      description: "Update an existing entry by its human-readable ID. Only provide the fields you want to change \u2014 data fields are merged with existing values. Creates a draft version by default. Set autoPublish=true to publish immediately. Use get-entry first to see current values. SOS-020: Cannot update tension status via MCP \u2014 process decides (use Product Brain UI after approval).",
       inputSchema: {
         entryId: z.string().describe("Entry ID to update, e.g. 'T-SUPPLIER', 'BR-001'"),
         name: z.string().optional().describe("New display name"),
         status: z.string().optional().describe("New status: draft | active | verified | deprecated"),
         data: z.record(z.unknown()).optional().describe("Fields to update (merged with existing data)"),
-        order: z.number().optional().describe("New sort order")
+        order: z.number().optional().describe("New sort order"),
+        autoPublish: z.boolean().optional().default(false).describe("If true, publishes the change immediately. If false (default), creates a draft version.")
       },
       annotations: { idempotentHint: true, destructiveHint: false }
     },
-    async ({ entryId, name, status, data, order }) => {
+    async ({ entryId, name, status, data, order, autoPublish }) => {
       try {
         const id = await mcpMutation("kb.updateEntry", {
           entryId,
           name,
           status,
           data,
-          order
+          order,
+          autoPublish
         });
+        const mode = autoPublish ? "published" : "saved as draft";
         return {
           content: [{ type: "text", text: `# Entry Updated
 
-**${entryId}** has been updated.
+**${entryId}** has been ${mode}.
 
 Internal ID: ${id}` }]
         };
@@ -428,7 +431,7 @@ Tension status (open, in-progress, closed) must be changed through the defined p
 - Create tensions: \`create-entry collection=tensions name="..." status=open\`
 - List tensions: \`list-entries collection=tensions\`
 - Update non-status fields (raised, date, priority, description) via \`update-entry\`
-- After process approval, a human uses the SynergyOS UI to change status
+- After process approval, a human uses the Product Brain UI to change status
 
 Process criteria (TBD): e.g. 3+ users approved, or 7 days without valid concerns.`
             }]
@@ -829,7 +832,7 @@ Use \`get-entry\` to inspect the existing entry, or \`update-entry\` to modify i
       await server2.sendLoggingMessage({
         level: "info",
         data: `Loading context for task: "${taskDescription.substring(0, 80)}..."`,
-        logger: "product-os"
+        logger: "product-brain"
       });
       const result = await mcpQuery("kb.loadContextForTask", {
         taskDescription,
@@ -885,7 +888,7 @@ _Consider capturing domain knowledge discovered during this task via \`smart-cap
     "review-rules",
     {
       title: "Review Business Rules",
-      description: "Surface all active business rules for a domain, formatted for compliance review. Use when reviewing code, designs, or decisions against ProductBrain governance. Optionally provide context (what you're building or reviewing) to help focus the review. This is the tool form of the review-against-rules prompt.",
+      description: "Surface all active business rules for a domain, formatted for compliance review. Use when reviewing code, designs, or decisions against Product Brain governance. Optionally provide context (what you're building or reviewing) to help focus the review. This is the tool form of the review-against-rules prompt.",
       inputSchema: {
         domain: z.string().describe("Business rule domain, e.g. 'AI & MCP Integration', 'Governance & Decision-Making'"),
         context: z.string().optional().describe("What you're reviewing \u2014 code change, design decision, file path, etc.")
@@ -1134,7 +1137,7 @@ function registerHealthTools(server2) {
     "health",
     {
       title: "Health Check",
-      description: "Verify that ProductBrain is running and can reach its backend. Returns workspace status, collection count, entry count, and latency. Use this to confirm connectivity before doing real work.",
+      description: "Verify that Product Brain is running and can reach its backend. Returns workspace status, collection count, entry count, and latency. Use this to confirm connectivity before doing real work.",
       annotations: { readOnlyHint: true }
     },
     async () => {
@@ -1380,7 +1383,7 @@ function registerVerifyTools(server2) {
         return {
           content: [{
             type: "text",
-            text: "# Verification Failed\n\nCannot find project root (looked for `convex/schema.ts` in cwd and parent directory).\n\nSet `WORKSPACE_PATH` in `.env.mcp` to the absolute path of the ProductBrain project root."
+            text: "# Verification Failed\n\nCannot find project root (looked for `convex/schema.ts` in cwd and parent directory).\n\nSet `WORKSPACE_PATH` in `.env.mcp` to the absolute path of the Product Brain project root."
           }]
         };
       }
@@ -1708,6 +1711,30 @@ var PROFILES = /* @__PURE__ */ new Map([
         suggestion: () => "Record when this decision was made."
       }
     ]
+  }],
+  ["features", {
+    idPrefix: "FEAT",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["belongs_to", "depends_on", "surfaces_tension_in", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      {
+        id: "has-owner",
+        label: "Owner assigned",
+        check: (ctx) => !!ctx.data.owner && ctx.data.owner !== "",
+        suggestion: () => "Assign an owner team or product area."
+      },
+      {
+        id: "has-rationale",
+        label: "Rationale documented",
+        check: (ctx) => !!ctx.data.rationale && String(ctx.data.rationale).length > 20,
+        suggestion: () => "Explain why this feature matters \u2014 what problem does it solve?"
+      }
+    ]
   }]
 ]);
 var FALLBACK_PROFILE = {
@@ -2077,220 +2104,1784 @@ function extractPreview2(data, maxLen) {
   return raw.length > maxLen ? raw.substring(0, maxLen) + "..." : raw;
 }
 
-// src/resources/index.ts
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-function formatEntryMarkdown(entry) {
-  const id = entry.entryId ? `${entry.entryId}: ` : "";
-  const lines = [`## ${id}${entry.name} [${entry.status}]`];
-  if (entry.data && typeof entry.data === "object") {
-    for (const [key, val] of Object.entries(entry.data)) {
-      if (val && key !== "rawData") {
-        lines.push(`**${key}**: ${typeof val === "string" ? val : JSON.stringify(val)}`);
-      }
-    }
-  }
-  return lines.join("\n");
+// src/tools/architecture.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { resolve as resolve2, relative, dirname, normalize } from "path";
+import { z as z6 } from "zod";
+var COLLECTION_SLUG = "architecture";
+var COLLECTION_FIELDS = [
+  { key: "archType", label: "Architecture Type", type: "select", required: true, options: ["template", "layer", "node", "flow"], searchable: true },
+  { key: "templateRef", label: "Template Entry ID", type: "text", searchable: false },
+  { key: "layerRef", label: "Layer Entry ID", type: "text", searchable: false },
+  { key: "description", label: "Description", type: "text", searchable: true },
+  { key: "color", label: "Color", type: "text" },
+  { key: "icon", label: "Icon", type: "text" },
+  { key: "sourceNode", label: "Source Node (flows)", type: "text" },
+  { key: "targetNode", label: "Target Node (flows)", type: "text" },
+  { key: "filePaths", label: "File Paths", type: "text", searchable: true },
+  { key: "owner", label: "Owner (circle/role)", type: "text", searchable: true },
+  { key: "layerOrder", label: "Layer Order (for templates)", type: "text" },
+  { key: "rationale", label: "Why Here? (placement rationale)", type: "text", searchable: true },
+  { key: "dependsOn", label: "Allowed Dependencies (layers this can import from)", type: "text" }
+];
+async function ensureCollection() {
+  const collections = await mcpQuery("kb.listCollections");
+  if (collections.some((c) => c.slug === COLLECTION_SLUG)) return;
+  await mcpMutation("kb.createCollection", {
+    slug: COLLECTION_SLUG,
+    name: "Architecture",
+    icon: "\u{1F3D7}\uFE0F",
+    description: "System architecture map \u2014 templates, layers, nodes, and flows. Visualized in the Architecture Explorer and via MCP architecture tools.",
+    fields: COLLECTION_FIELDS
+  });
 }
-function buildOrientationMarkdown(collections, trackingEvents, standards, businessRules) {
-  const sections = ["# ProductBrain \u2014 Orientation"];
-  sections.push(
-    "## Architecture\n```\nCursor (stdio) \u2192 MCP Server (mcp-server/src/index.ts)\n  \u2192 POST /api/mcp with Bearer token\n  \u2192 Convex HTTP Action (convex/http.ts)\n  \u2192 internalQuery / internalMutation (convex/mcpKnowledge.ts)\n  \u2192 Convex DB (workspace-scoped)\n```\nSecurity: API key auth on every request, workspace-scoped data, internal functions blocked from external clients.\nKey files: `mcp-server/src/client.ts` (HTTP client + audit), `convex/schema.ts` (9-table schema)."
-  );
-  if (collections) {
-    const collList = collections.map((c) => {
-      const prefix = c.icon ? `${c.icon} ` : "";
-      return `- ${prefix}**${c.name}** (\`${c.slug}\`) \u2014 ${c.description || "no description"}`;
-    }).join("\n");
-    sections.push(
-      `## Data Model (${collections.length} collections)
-Unified entries model: collections define field schemas, entries hold data in a flexible \`data\` field.
-Tags for filtering (e.g. \`severity:high\`), relations via \`entryRelations\`, history via \`entryHistory\`, labels via \`labels\` + \`entryLabels\`.
-
-` + collList + "\n\nUse `list-collections` for field schemas, `get-entry` for full records."
-    );
-  } else {
-    sections.push(
-      "## Data Model\nCould not load collections \u2014 use `list-collections` to browse manually."
+async function listArchEntries() {
+  return mcpQuery("kb.listEntries", { collectionSlug: COLLECTION_SLUG });
+}
+function byTag(entries, archType) {
+  return entries.filter((e) => e.tags?.includes(`archType:${archType}`) || e.data?.archType === archType).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
+function renderArchitectureHtml(layers, nodes, flows, templateName) {
+  const layerHtml = layers.map((layer) => {
+    const layerNodes = nodes.filter(
+      (n) => n.data?.layerRef === layer.entryId
     );
-  }
-  const rulesCount = businessRules ? `${businessRules.length} entries` : "not loaded \u2014 collection may not exist yet";
-  sections.push(
-    `## Business Rules
-Collection: \`business-rules\` (${rulesCount}).
-Find rules: \`kb-search\` for text search, \`list-entries collection=business-rules\` to browse.
-Check compliance: use the \`review-against-rules\` prompt (pass a domain).
-Draft a new rule: use the \`draft-rule-from-context\` prompt.`
-  );
-  const eventsCount = trackingEvents ? `${trackingEvents.length} events` : "not loaded \u2014 collection may not exist yet";
-  const conventionNote = standards ? "Naming convention: `object_action` in snake_case with past-tense verbs (from standards collection)." : "Naming convention: `object_action` in snake_case with past-tense verbs.";
-  sections.push(
-    `## Analytics & Tracking
-Event catalog: \`tracking-events\` collection (${eventsCount}).
-${conventionNote}
-Implementation: \`src/lib/analytics.ts\`. Workspace-scoped events MUST use \`withWorkspaceGroup()\`.
-Browse: \`list-entries collection=tracking-events\`.`
-  );
-  sections.push(
-    "## Knowledge Graph\nEntries are connected via typed relations (`entryRelations` table). Relations are bidirectional and collection-agnostic \u2014 any entry can link to any other entry.\n\n**Recommended relation types** (extensible \u2014 any string accepted):\n- `governs` \u2014 a rule constrains behavior of a feature\n- `defines_term_for` \u2014 a glossary term is canonical vocabulary for a feature/area\n- `belongs_to` \u2014 a feature belongs to a product area or parent concept\n- `informs` \u2014 a decision or insight informs a feature\n- `surfaces_tension_in` \u2014 a tension exists within a feature area\n- `related_to`, `depends_on`, `replaces`, `conflicts_with`, `references`, `confused_with`\n\nEach relation type is defined as a glossary entry (prefix `GT-REL-*`) to prevent terminology drift.\n\n**Tools:**\n- `gather-context` \u2014 get the full context around any entry (multi-hop graph traversal)\n- `suggest-links` \u2014 discover potential connections for an entry\n- `relate-entries` \u2014 create a typed link between two entries\n- `find-related` \u2014 list direct relations for an entry\n\n**Convention:** When creating or updating entries in governed collections, always use `suggest-links` to discover and create relevant relations."
-  );
-  sections.push(
-    "## Creating Knowledge\nUse `smart-capture` as the primary tool for creating new entries. It handles the full workflow in one call:\n1. Creates the entry with collection-aware defaults (auto-fills dates, infers domains, sets priority)\n2. Auto-links related entries from across the knowledge base (up to 5 confident matches)\n3. Returns a quality scorecard (X/10) with actionable improvement suggestions\n\n**Smart profiles** exist for: `tensions`, `business-rules`, `glossary`, `decisions`.\nAll other collections use sensible defaults.\n\nExample: `smart-capture collection='tensions' name='...' description='...'`\n\nUse `quality-check` to score existing entries retroactively.\nUse `create-entry` only when you need full control over every field.\nUse `quick-capture` for minimal ceremony without auto-linking."
-  );
-  sections.push(
-    "## Where to Go Next\n- **Create entry** \u2192 `smart-capture` tool (auto-links + quality score in one call)\n- **Full context** \u2192 `gather-context` tool (start here when working on a feature)\n- **Discover links** \u2192 `suggest-links` tool\n- **Quality audit** \u2192 `quality-check` tool\n- **Terminology** \u2192 `name-check` prompt or `productbrain://terminology` resource\n- **Schema details** \u2192 `productbrain://collections` resource or `list-collections` tool\n- **Labels** \u2192 `productbrain://labels` resource or `list-labels` tool\n- **Any collection** \u2192 `productbrain://{slug}/entries` resource\n- **Log a decision** \u2192 `draft-decision-record` prompt\n- **Health check** \u2192 `health` tool\n- **Debug MCP calls** \u2192 `mcp-audit` tool"
-  );
-  return sections.join("\n\n---\n\n");
+    const nodeCards = layerNodes.map((n) => `
+      <div class="node" title="${escHtml(String(n.data?.description ?? ""))}">
+        <span class="node-icon">${escHtml(String(n.data?.icon ?? "\u25FB"))}</span>
+        <span class="node-name">${escHtml(n.name)}</span>
+      </div>
+    `).join("");
+    return `
+      <div class="layer" style="--layer-color: ${escHtml(String(layer.data?.color ?? "#666"))}">
+        <div class="layer-label">
+          <span class="layer-dot"></span>
+          <span class="layer-name">${escHtml(layer.name)}</span>
+          <span class="layer-count">${layerNodes.length}</span>
+        </div>
+        <div class="layer-desc">${escHtml(String(layer.data?.description ?? ""))}</div>
+        <div class="nodes">${nodeCards || '<span class="empty">No components</span>'}</div>
+      </div>
+    `;
+  }).join("");
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:-apple-system,system-ui,sans-serif;background:#1a1a2e;color:#e0e0e0;padding:16px}
+h1{font-size:14px;font-weight:600;color:#a0a0c0;margin-bottom:12px;letter-spacing:.04em}
+.layer{border-left:3px solid var(--layer-color);padding:8px 12px;margin-bottom:8px;background:rgba(255,255,255,.03);border-radius:0 6px 6px 0}
+.layer-label{display:flex;align-items:center;gap:8px;margin-bottom:4px}
+.layer-dot{width:8px;height:8px;border-radius:50%;background:var(--layer-color)}
+.layer-name{font-size:12px;font-weight:600;color:#fff;letter-spacing:.03em}
+.layer-count{font-size:10px;color:var(--layer-color);background:rgba(255,255,255,.06);padding:1px 6px;border-radius:8px}
+.layer-desc{font-size:11px;color:#888;margin-bottom:6px}
+.nodes{display:flex;flex-wrap:wrap;gap:6px}
+.node{display:flex;align-items:center;gap:4px;background:rgba(255,255,255,.06);border:1px solid rgba(255,255,255,.08);border-radius:4px;padding:4px 8px;font-size:11px;cursor:default;transition:border-color .15s}
+.node:hover{border-color:var(--layer-color)}
+.node-icon{font-size:12px}
+.node-name{color:#ddd}
+.empty{font-size:11px;color:#555;font-style:italic}
+.flows{margin-top:12px;border-top:1px solid rgba(255,255,255,.06);padding-top:8px}
+.flow{font-size:11px;color:#888;padding:2px 0}
+.flow-arrow{color:#6366f1;margin:0 4px}
+</style></head><body>
+<h1>${escHtml(templateName)}</h1>
+${layerHtml}
+${flows.length > 0 ? `<div class="flows"><div style="font-size:10px;color:#666;margin-bottom:4px;letter-spacing:.06em">DATA FLOWS</div>${flows.map((f) => `<div class="flow">${escHtml(f.name)}<span class="flow-arrow">\u2192</span><span style="color:#aaa">${escHtml(String(f.data?.description ?? ""))}</span></div>`).join("")}</div>` : ""}
+</body></html>`;
 }
-function registerResources(server2) {
-  server2.resource(
-    "kb-orientation",
-    "productbrain://orientation",
-    async (uri) => {
-      const [collectionsResult, eventsResult, standardsResult, rulesResult] = await Promise.allSettled([
-        mcpQuery("kb.listCollections"),
-        mcpQuery("kb.listEntries", { collectionSlug: "tracking-events" }),
-        mcpQuery("kb.listEntries", { collectionSlug: "standards" }),
-        mcpQuery("kb.listEntries", { collectionSlug: "business-rules" })
-      ]);
-      const collections = collectionsResult.status === "fulfilled" ? collectionsResult.value : null;
-      const trackingEvents = eventsResult.status === "fulfilled" ? eventsResult.value : null;
-      const standards = standardsResult.status === "fulfilled" ? standardsResult.value : null;
-      const businessRules = rulesResult.status === "fulfilled" ? rulesResult.value : null;
-      return {
-        contents: [{
-          uri: uri.href,
-          text: buildOrientationMarkdown(collections, trackingEvents, standards, businessRules),
-          mimeType: "text/markdown"
-        }]
-      };
-    }
-  );
-  server2.resource(
-    "kb-terminology",
-    "productbrain://terminology",
-    async (uri) => {
-      const [glossaryResult, standardsResult] = await Promise.allSettled([
-        mcpQuery("kb.listEntries", { collectionSlug: "glossary" }),
-        mcpQuery("kb.listEntries", { collectionSlug: "standards" })
-      ]);
-      const lines = ["# ProductBrain \u2014 Terminology"];
-      if (glossaryResult.status === "fulfilled") {
-        if (glossaryResult.value.length > 0) {
-          const terms = glossaryResult.value.map((t) => `- **${t.name}** (${t.entryId ?? "\u2014"}) [${t.status}]: ${t.data?.canonical ?? t.data?.description ?? ""}`).join("\n");
-          lines.push(`## Glossary (${glossaryResult.value.length} terms)
+function escHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function formatLayerText(layer, nodes) {
+  const layerNodes = nodes.filter((n) => n.data?.layerRef === layer.entryId);
+  const nodeList = layerNodes.map((n) => {
+    const desc = n.data?.description ? ` \u2014 ${n.data.description}` : "";
+    const owner = n.data?.owner ? ` (${n.data.owner})` : "";
+    return `  - ${n.data?.icon ?? "\u25FB"} **${n.name}**${desc}${owner}`;
+  }).join("\n");
+  return `### ${layer.name}
+${layer.data?.description ?? ""}
 
-${terms}`);
-        } else {
-          lines.push("## Glossary\n\nNo glossary terms yet. Use `create-entry` with collection `glossary` to add terms.");
-        }
-      } else {
-        lines.push("## Glossary\n\nCould not load glossary \u2014 use `list-entries collection=glossary` to browse manually.");
+${nodeList || "  _No components_"}`;
+}
+var SEED_TEMPLATE = {
+  entryId: "ARCH-tpl-product-os",
+  name: "Product OS Default",
+  data: {
+    archType: "template",
+    description: "Default 4-layer architecture: Auth \u2192 Infrastructure \u2192 Core \u2192 Features, with an outward Integration layer",
+    layerOrder: JSON.stringify(["auth", "infrastructure", "core", "features", "integration"])
+  }
+};
+var SEED_LAYERS = [
+  { entryId: "ARCH-layer-auth", name: "Auth", order: 0, data: { archType: "layer", templateRef: "ARCH-tpl-product-os", color: "#22c55e", description: "Authentication, user management, and workspace-scoped access control", icon: "\u{1F510}", dependsOn: "none", rationale: "Foundation layer. Auth depends on nothing \u2014 it is the first gate. No layer may bypass auth. All other layers depend on auth to know who the user is and which workspace they belong to." } },
+  { entryId: "ARCH-layer-infra", name: "Infrastructure", order: 1, data: { archType: "layer", templateRef: "ARCH-tpl-product-os", color: "#ec4899", description: "Real-time data, event tracking, and AI model infrastructure", icon: "\u2699\uFE0F", dependsOn: "Auth", rationale: "Infrastructure sits on top of Auth. It provides the database, analytics, and AI plumbing that Core and Features consume. Infra may import from Auth (needs workspace context) but never from Core or Features." } },
+  { entryId: "ARCH-layer-core", name: "Core", order: 2, data: { archType: "layer", templateRef: "ARCH-tpl-product-os", color: "#8b5cf6", description: "Business logic, knowledge graph, workflow engines, and MCP tooling", icon: "\u{1F9E0}", dependsOn: "Auth, Infrastructure", rationale: "Core contains business logic and engines that are UI-agnostic. It may import from Auth and Infra. Features depend on Core, but Core must never depend on Features \u2014 this is what keeps engines reusable across different UIs." } },
+  { entryId: "ARCH-layer-features", name: "Features", order: 3, data: { archType: "layer", templateRef: "ARCH-tpl-product-os", color: "#6366f1", description: "User-facing pages, components, and feature modules", icon: "\u2726", dependsOn: "Auth, Infrastructure, Core", rationale: "Features are the user-facing layer \u2014 SvelteKit routes, components, and page-level logic. Features may import from any lower layer but nothing above may import from Features. This is the outermost application layer." } },
+  { entryId: "ARCH-layer-integration", name: "Integration", order: 4, data: { archType: "layer", templateRef: "ARCH-tpl-product-os", color: "#f59e0b", description: "Outward connections to external tools, IDEs, and services", icon: "\u{1F50C}", dependsOn: "Core", rationale: "Integration is a lateral/outward layer \u2014 it connects to external systems (IDE, GitHub, Linear). It depends on Core (to expose knowledge) but sits outside the main stack. External tools call into Core via Integration, never directly into Features." } }
+];
+var SEED_NODES = [
+  // Auth layer
+  { entryId: "ARCH-node-clerk", name: "Clerk", order: 0, data: { archType: "node", layerRef: "ARCH-layer-auth", color: "#22c55e", icon: "\u{1F511}", description: "Authentication provider \u2014 sign-in/sign-up pages, session management, organization-level access control. UserSync.svelte is cross-cutting layout glue (not mapped here).", filePaths: "src/routes/sign-in/, src/routes/sign-up/", owner: "Platform", rationale: "Auth layer because Clerk is the identity gate. Every request flows through auth first. No other layer provides identity." } },
+  { entryId: "ARCH-node-workspace", name: "Workspace Scoping", order: 1, data: { archType: "node", layerRef: "ARCH-layer-auth", color: "#22c55e", icon: "\u{1F3E2}", description: "Multi-tenancy anchor \u2014 all data is workspace-scoped via workspaceId", filePaths: "src/lib/stores/workspace.ts, convex/workspaces.ts", owner: "Platform", rationale: "Auth layer because workspace scoping is the second gate after identity. All queries require workspaceId, making this foundational." } },
+  // Infrastructure layer
+  { entryId: "ARCH-node-convex", name: "Convex", order: 0, data: { archType: "node", layerRef: "ARCH-layer-infra", color: "#ec4899", icon: "\u26A1", description: "Reactive database with real-time sync, serverless functions, and type-safe API generation. Unified Collections + Entries model", filePaths: "convex/schema.ts, convex/entries.ts, convex/http.ts", owner: "Platform", rationale: "Infrastructure because Convex is raw persistence and reactivity plumbing. It stores data but has no business logic opinions. Core and Features consume it." } },
+  { entryId: "ARCH-node-posthog", name: "PostHog", order: 1, data: { archType: "node", layerRef: "ARCH-layer-infra", color: "#ec4899", icon: "\u{1F4CA}", description: "Product analytics \u2014 workspace-scoped events, feature flags, session replay", filePaths: "src/lib/analytics.ts, src/lib/components/PostHogWorkspaceSync.svelte", owner: "Platform", rationale: "Infrastructure because PostHog is analytics plumbing \u2014 event collection and aggregation. It has no knowledge of business domains." } },
+  { entryId: "ARCH-node-openrouter", name: "OpenRouter", order: 2, data: { archType: "node", layerRef: "ARCH-layer-infra", color: "#ec4899", icon: "\u{1F916}", description: "AI model routing for ChainWork artifact generation \u2014 streaming responses with format-aware prompts", filePaths: "src/routes/api/chainwork/generate/+server.ts", owner: "ChainWork", rationale: "Infrastructure because OpenRouter is an AI model gateway \u2014 it routes prompts to models. The strategy logic lives in ChainWork Engine (Core); this is just the pipe." } },
+  // Core layer
+  { entryId: "ARCH-node-mcp", name: "MCP Server", order: 0, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u{1F527}", description: "20+ tools exposing the knowledge graph as AI-consumable operations \u2014 smart-capture, context assembly, verification, quality checks", filePaths: "packages/mcp-server/src/index.ts, packages/mcp-server/src/tools/", owner: "AI DX", rationale: "Core layer because the MCP server encodes business operations \u2014 smart-capture with auto-linking, quality scoring, governance rules. It depends on Infra (Convex) but never touches UI routes. Why not Infrastructure? Because it has domain opinions. Why not Features? Because it has no UI \u2014 any client (Cursor, CLI, API) can call it." } },
+  { entryId: "ARCH-node-knowledge-graph", name: "Knowledge Graph", order: 1, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u{1F578}\uFE0F", description: "20 collections, 170+ entries with typed cross-collection relations. Smart capture, auto-linking, quality scoring", filePaths: "convex/mcpKnowledge.ts, convex/entries.ts", owner: "Knowledge", rationale: "Core layer because the knowledge graph IS the domain model \u2014 collections, entries, relations, versioning, quality scoring. Glossary DATA, business rules DATA, tension DATA all live here. Why not Features? Because the data model exists independently of any page. The Glossary page in Features is just one way to visualize terms that Core owns. Think: Core owns the dictionary, Features owns the dictionary app." } },
+  { entryId: "ARCH-node-governance", name: "Governance Engine", order: 2, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u2696\uFE0F", description: "Circles, roles, consent-based decision-making, tension processing with IDM-inspired async workflows", filePaths: "convex/versioning.ts, src/lib/components/versioning/", owner: "Governance", rationale: "Core layer because governance logic (draft\u2192publish workflows, consent-based decisions, tension status rules) is business process that multiple UIs consume. Why not Features? Because the versioning system and proposal flow are reusable engines \u2014 the Governance Pages in Features are just one rendering of these rules." } },
+  { entryId: "ARCH-node-chainwork-engine", name: "ChainWork Engine", order: 3, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u26D3", description: "Guided strategy creation through 5-step coherence chain \u2014 AI-generated artifacts with scoring and achievements", filePaths: "src/lib/components/chainwork/config.ts, src/lib/components/chainwork/scoring.ts", owner: "ChainWork", rationale: "Core layer because the coherence chain logic, scoring algorithm, and quality gates are business rules. config.ts defines chain steps, scoring.ts computes quality \u2014 these could power a CLI or API. Why not Features? Because the ChainWork UI wizard in Features is just one skin over this engine." } },
+  // Features layer
+  { entryId: "ARCH-node-command-center", name: "Command Center", order: 0, data: { archType: "node", layerRef: "ARCH-layer-features", color: "#6366f1", icon: "\u2B21", description: "Calm home screen \u2014 daily orientation, triage mode, pulse metrics, momentum tracking", filePaths: "src/routes/+page.svelte, src/lib/components/command-center/", owner: "Command Center", rationale: "Features layer because the Command Center is a SvelteKit page \u2014 PulseMetrics, NeedsAttention, DailyBriefing are UI components that assemble data from Core queries. Why not Core? Because it has no reusable business logic or engines \u2014 it is pure layout and presentation. If you deleted this page, no business rule would break." } },
+  { entryId: "ARCH-node-chainwork-ui", name: "ChainWork UI", order: 1, data: { archType: "node", layerRef: "ARCH-layer-features", color: "#6366f1", icon: "\u26D3", description: "Multi-step wizard for strategy artifact creation \u2014 setup, chain steps, quality gates, output", filePaths: "src/routes/chainwork/, src/lib/components/chainwork/", owner: "ChainWork", rationale: "Features layer because the ChainWork UI is the wizard interface \u2014 step navigation, form inputs, output rendering. Why not Core? Because the scoring logic and chain config ARE in Core (ChainWork Engine). This is the presentation skin over that engine. Delete this page and the engine still works via MCP." } },
+  { entryId: "ARCH-node-glossary", name: "Glossary", order: 2, data: { archType: "node", layerRef: "ARCH-layer-features", color: "#6366f1", icon: "Aa", description: "Canonical vocabulary management \u2014 term detail, code drift detection, inline term linking", filePaths: "src/routes/glossary/, src/lib/components/glossary/", owner: "Knowledge", rationale: "Features layer \u2014 NOT Core or Infrastructure \u2014 because this is the Glossary PAGE: the SvelteKit route for browsing, editing, and viewing terms. Why not Core? Because Core owns the glossary DATA (Knowledge Graph) and term-linking logic. The MCP server also accesses glossary terms without any page. Why not Infrastructure? Because glossary is domain-specific vocabulary, not generic plumbing. The page is one consumer of the data \u2014 Core owns the dictionary, Features owns the dictionary app." } },
+  { entryId: "ARCH-node-tensions", name: "Tensions", order: 3, data: { archType: "node", layerRef: "ARCH-layer-features", color: "#6366f1", icon: "\u26A1", description: "Tension capture and processing \u2014 raise, triage, resolve through governance workflow", filePaths: "src/routes/tensions/, src/lib/components/tensions/", owner: "Governance", rationale: "Features layer because this is the Tensions PAGE \u2014 the UI for raising, listing, and viewing tensions. Why not Core? Because tension data, status rules (SOS-020), and processing logic already live in Core (Governance Engine). This page is a form + list view that reads from and writes to Core. Delete it and the governance engine still processes tensions via MCP." } },
+  { entryId: "ARCH-node-strategy", name: "Strategy", order: 4, data: { archType: "node", layerRef: "ARCH-layer-features", color: "#6366f1", icon: "\u25A3", description: "Product strategy pages \u2014 vision, ecosystem, product areas, decision frameworks, sequencing", filePaths: "src/routes/strategy/, src/routes/bridge/, src/routes/topology/", owner: "Strategy", rationale: "Features layer because Strategy is a set of SvelteKit pages (strategy, bridge, topology) that visualize strategy entries. Why not Core? Because the strategy data (vision, principles, ecosystem layers) lives in the Knowledge Graph (Core). These pages render and allow inline editing \u2014 they consume Core downward." } },
+  { entryId: "ARCH-node-governance-ui", name: "Governance Pages", order: 5, data: { archType: "node", layerRef: "ARCH-layer-features", color: "#6366f1", icon: "\u25C8", description: "Roles, circles, principles, policies, decisions, proposals, business rules", filePaths: "src/routes/roles/, src/routes/circles/, src/routes/decisions/, src/routes/proposals/", owner: "Governance", rationale: "Features layer because these are governance PAGES \u2014 list views and detail views for roles, circles, decisions, proposals. Why not Core? Because the governance ENGINE (versioning, consent, IDM) IS in Core. These pages are the user-facing window into governance data. The logic doesn't live here, only the rendering." } },
+  { entryId: "ARCH-node-artifacts", name: "Artifacts", order: 6, data: { archType: "node", layerRef: "ARCH-layer-features", color: "#6366f1", icon: "\u{1F4C4}", description: "Strategy artifacts from ChainWork \u2014 pitches, briefs, one-pagers linked to the knowledge graph", filePaths: "src/routes/artifacts/", owner: "ChainWork", rationale: "Features layer because the Artifacts page is a list/detail view for strategy artifacts produced by ChainWork. Why not Core? Because artifact data and scoring live in Core (ChainWork Engine). This page just renders the output and links back to the knowledge graph." } },
+  // Integration layer
+  { entryId: "ARCH-node-cursor", name: "Cursor IDE", order: 0, data: { archType: "node", layerRef: "ARCH-layer-integration", color: "#f59e0b", icon: "\u{1F5A5}\uFE0F", description: "AI-assisted development with MCP-powered knowledge context \u2014 smart capture, verification, context assembly in the editor", filePaths: ".cursor/mcp.json, .cursor/rules/", owner: "AI DX", rationale: "Integration layer because Cursor is an external tool that connects INTO our system via MCP. Why not Core or Features? Because Cursor itself is not our code \u2014 it's a consumer. The .cursor/ config files define how it talks to us, but Cursor lives outside our deployment boundary." } },
+  { entryId: "ARCH-node-github", name: "GitHub", order: 1, data: { archType: "node", layerRef: "ARCH-layer-integration", color: "#f59e0b", icon: "\u{1F419}", description: "Code repository, PR reviews with governance context, CI/CD", owner: "Platform", rationale: "Integration layer because GitHub is an external service. Why not Infrastructure? Because Infra is about plumbing we control (database, analytics). GitHub is a third-party that hooks into our Core (PR reviews checking governance rules) but is not part of our deployed application." } },
+  { entryId: "ARCH-node-linear", name: "Linear (planned)", order: 2, data: { archType: "node", layerRef: "ARCH-layer-integration", color: "#f59e0b", icon: "\u{1F4D0}", description: "Issue tracking, roadmap sync, tension-to-issue pipeline (planned integration)", owner: "Platform", rationale: "Integration layer because Linear is an external issue tracker. Why not Infrastructure? Because Infra is generic plumbing we run. Linear is a third-party tool we connect to. The planned pipeline bridges tensions (Core) to Linear issues \u2014 a classic outward integration pattern." } }
+];
+var SEED_FLOWS = [
+  { entryId: "ARCH-flow-smart-capture", name: "Smart Capture Flow", order: 0, data: { archType: "flow", sourceNode: "ARCH-node-cursor", targetNode: "ARCH-node-knowledge-graph", description: "Developer/AI calls smart-capture via MCP \u2192 entry created with auto-linking and quality score \u2192 stored in Knowledge Graph", color: "#8b5cf6" } },
+  { entryId: "ARCH-flow-governance", name: "Governance Flow", order: 1, data: { archType: "flow", sourceNode: "ARCH-node-tensions", targetNode: "ARCH-node-governance", description: "Tension raised \u2192 appears in Command Center \u2192 triaged \u2192 processed via IDM \u2192 decision logged", color: "#6366f1" } },
+  { entryId: "ARCH-flow-chainwork", name: "ChainWork Strategy Flow", order: 2, data: { archType: "flow", sourceNode: "ARCH-node-chainwork-ui", targetNode: "ARCH-node-artifacts", description: "Leader opens ChainWork \u2192 walks coherence chain \u2192 AI generates artifact \u2192 scored and published to knowledge graph", color: "#f59e0b" } },
+  { entryId: "ARCH-flow-knowledge-trust", name: "Knowledge Trust Flow", order: 3, data: { archType: "flow", sourceNode: "ARCH-node-mcp", targetNode: "ARCH-node-glossary", description: "MCP verify tool checks entries against codebase \u2192 file existence, schema references validated \u2192 trust scores updated", color: "#22c55e" } },
+  { entryId: "ARCH-flow-analytics", name: "Analytics Flow", order: 4, data: { archType: "flow", sourceNode: "ARCH-node-command-center", targetNode: "ARCH-node-posthog", description: "Feature views and actions tracked \u2192 workspace-scoped events \u2192 PostHog group analytics \u2192 Command Center metrics", color: "#ec4899" } }
+];
+function registerArchitectureTools(server2) {
+  server2.registerTool(
+    "show-architecture",
+    {
+      title: "Show Architecture",
+      description: "Render the system architecture map \u2014 layered visualization showing where every component lives. Returns layers (Auth \u2192 Infrastructure \u2192 Core \u2192 Features \u2192 Integration) with component nodes and data flows. Optionally filter by a specific template.",
+      inputSchema: {
+        template: z6.string().optional().describe("Template entry ID to filter by (default: first available template)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ template }) => {
+      await ensureCollection();
+      const all = await listArchEntries();
+      const templates = byTag(all, "template");
+      const activeTemplate = template ? templates.find((t) => t.entryId === template) : templates[0];
+      const templateName = activeTemplate?.name ?? "System Architecture";
+      const templateId = activeTemplate?.entryId;
+      const layers = byTag(all, "layer").filter((l) => !templateId || l.data?.templateRef === templateId);
+      const nodes = byTag(all, "node");
+      const flows = byTag(all, "flow");
+      if (layers.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "# Architecture Explorer\n\nNo architecture data found. Use `seed-architecture` to populate the default Product OS architecture."
+          }]
+        };
       }
-      if (standardsResult.status === "fulfilled") {
-        if (standardsResult.value.length > 0) {
-          const stds = standardsResult.value.map((s) => `- **${s.name}** (${s.entryId ?? "\u2014"}) [${s.status}]: ${s.data?.description ?? ""}`).join("\n");
-          lines.push(`## Standards (${standardsResult.value.length} entries)
+      const textLayers = layers.map((l) => formatLayerText(l, nodes)).join("\n\n");
+      const textFlows = flows.length > 0 ? "\n\n---\n\n## Data Flows\n\n" + flows.map(
+        (f) => `- **${f.name}**: ${f.data?.description ?? ""}`
+      ).join("\n") : "";
+      const text = `# ${templateName}
 
-${stds}`);
-        } else {
-          lines.push("## Standards\n\nNo standards yet. Use `create-entry` with collection `standards` to add standards.");
-        }
-      } else {
-        lines.push("## Standards\n\nCould not load standards \u2014 use `list-entries collection=standards` to browse manually.");
-      }
+${textLayers}${textFlows}`;
+      const html = renderArchitectureHtml(layers, nodes, flows, templateName);
       return {
-        contents: [{ uri: uri.href, text: lines.join("\n\n---\n\n"), mimeType: "text/markdown" }]
+        content: [
+          { type: "text", text },
+          { type: "resource", resource: { uri: `ui://product-os/architecture`, mimeType: "text/html", text: html } }
+        ]
       };
     }
   );
-  server2.resource(
-    "kb-collections",
-    "productbrain://collections",
-    async (uri) => {
-      const collections = await mcpQuery("kb.listCollections");
-      if (collections.length === 0) {
-        return { contents: [{ uri: uri.href, text: "No collections in this workspace.", mimeType: "text/markdown" }] };
+  server2.registerTool(
+    "explore-layer",
+    {
+      title: "Explore Architecture Layer",
+      description: "Drill into a specific architecture layer to see all its component nodes with descriptions, team ownership, file paths, and linked entry counts.",
+      inputSchema: {
+        layer: z6.string().describe("Layer name or entry ID, e.g. 'Core' or 'ARCH-layer-core'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ layer }) => {
+      await ensureCollection();
+      const all = await listArchEntries();
+      const layers = byTag(all, "layer");
+      const target = layers.find(
+        (l) => l.name.toLowerCase() === layer.toLowerCase() || l.entryId === layer
+      );
+      if (!target) {
+        const available = layers.map((l) => `\`${l.name}\``).join(", ");
+        return {
+          content: [{
+            type: "text",
+            text: `Layer "${layer}" not found. Available layers: ${available}`
+          }]
+        };
       }
-      const formatted = collections.map((c) => {
-        const fieldList = c.fields.map((f) => `  - \`${f.key}\` (${f.type}${f.required ? ", required" : ""}${f.searchable ? ", searchable" : ""})`).join("\n");
-        return `## ${c.icon ?? ""} ${c.name} (\`${c.slug}\`)
-${c.description || ""}
-
-**Fields:**
-${fieldList}`;
-      }).join("\n\n---\n\n");
+      const nodes = byTag(all, "node").filter((n) => n.data?.layerRef === target.entryId);
+      const flows = byTag(all, "flow").filter(
+        (f) => nodes.some((n) => n.entryId === f.data?.sourceNode || n.entryId === f.data?.targetNode)
+      );
+      const depRule = target.data?.dependsOn ? `
+**Dependency rule:** May import from ${target.data.dependsOn === "none" ? "nothing (foundation layer)" : target.data.dependsOn}.
+` : "";
+      const layerRationale = target.data?.rationale ? `
+> ${target.data.rationale}
+` : "";
+      const nodeDetail = nodes.map((n) => {
+        const lines = [`#### ${n.data?.icon ?? "\u25FB"} ${n.name}`];
+        if (n.data?.description) lines.push(String(n.data.description));
+        if (n.data?.owner) lines.push(`**Owner:** ${n.data.owner}`);
+        if (n.data?.filePaths) lines.push(`**Files:** \`${n.data.filePaths}\``);
+        if (n.data?.rationale) lines.push(`
+**Why here?** ${n.data.rationale}`);
+        return lines.join("\n");
+      }).join("\n\n");
+      const flowLines = flows.length > 0 ? "\n\n### Connected Flows\n\n" + flows.map((f) => `- ${f.name}: ${f.data?.description ?? ""}`).join("\n") : "";
       return {
-        contents: [{ uri: uri.href, text: `# Knowledge Collections (${collections.length})
+        content: [{
+          type: "text",
+          text: `# ${target.data?.icon ?? ""} ${target.name} Layer
 
-${formatted}`, mimeType: "text/markdown" }]
+${target.data?.description ?? ""}${depRule}${layerRationale}
+**${nodes.length} components**
+
+${nodeDetail}${flowLines}`
+        }]
       };
     }
   );
-  server2.resource(
-    "kb-collection-entries",
-    new ResourceTemplate("productbrain://{slug}/entries", {
-      list: async () => {
-        const collections = await mcpQuery("kb.listCollections");
+  server2.registerTool(
+    "show-flow",
+    {
+      title: "Show Architecture Flow",
+      description: "Visualize a specific data flow path between architecture nodes \u2014 shows source, target, and description.",
+      inputSchema: {
+        flow: z6.string().describe("Flow name or entry ID, e.g. 'Smart Capture Flow' or 'ARCH-flow-smart-capture'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ flow }) => {
+      await ensureCollection();
+      const all = await listArchEntries();
+      const flows = byTag(all, "flow");
+      const target = flows.find(
+        (f) => f.name.toLowerCase() === flow.toLowerCase() || f.entryId === flow
+      );
+      if (!target) {
+        const available = flows.map((f) => `\`${f.name}\``).join(", ");
         return {
-          resources: collections.map((c) => ({
-            uri: `productbrain://${c.slug}/entries`,
-            name: `${c.icon ?? ""} ${c.name}`.trim()
-          }))
+          content: [{
+            type: "text",
+            text: `Flow "${flow}" not found. Available flows: ${available}`
+          }]
         };
       }
-    }),
-    async (uri, { slug }) => {
-      const entries = await mcpQuery("kb.listEntries", { collectionSlug: slug });
-      const formatted = entries.map(formatEntryMarkdown).join("\n\n---\n\n");
-      return {
-        contents: [{
-          uri: uri.href,
-          text: formatted || "No entries in this collection.",
-          mimeType: "text/markdown"
-        }]
-      };
-    }
-  );
-  server2.resource(
-    "kb-labels",
-    "productbrain://labels",
-    async (uri) => {
-      const labels = await mcpQuery("kb.listLabels");
-      if (labels.length === 0) {
-        return { contents: [{ uri: uri.href, text: "No labels in this workspace.", mimeType: "text/markdown" }] };
+      const nodes = byTag(all, "node");
+      const source = nodes.find((n) => n.entryId === target.data?.sourceNode);
+      const dest = nodes.find((n) => n.entryId === target.data?.targetNode);
+      const lines = [
+        `# ${target.name}`,
+        "",
+        `**${source?.data?.icon ?? "?"} ${source?.name ?? "Unknown"}** \u2192 **${dest?.data?.icon ?? "?"} ${dest?.name ?? "Unknown"}**`,
+        "",
+        String(target.data?.description ?? "")
+      ];
+      if (source) {
+        lines.push("", `### Source: ${source.name}`, String(source.data?.description ?? ""));
+        if (source.data?.filePaths) lines.push(`Files: \`${source.data.filePaths}\``);
       }
-      const groups = labels.filter((l) => l.isGroup);
-      const ungrouped = labels.filter((l) => !l.isGroup && !l.parentId);
-      const children = (parentId) => labels.filter((l) => l.parentId === parentId);
-      const lines = [];
-      for (const group of groups) {
-        lines.push(`## ${group.name}`);
-        for (const child of children(group._id)) {
-          lines.push(`- \`${child.slug}\` ${child.name}${child.color ? ` (${child.color})` : ""}`);
-        }
+      if (dest) {
+        lines.push("", `### Target: ${dest.name}`, String(dest.data?.description ?? ""));
+        if (dest.data?.filePaths) lines.push(`Files: \`${dest.data.filePaths}\``);
       }
-      if (ungrouped.length > 0) {
-        lines.push("## Ungrouped");
-        for (const l of ungrouped) {
-          lines.push(`- \`${l.slug}\` ${l.name}${l.color ? ` (${l.color})` : ""}`);
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "seed-architecture",
+    {
+      title: "Seed Architecture Data",
+      description: "Populate the architecture collection with the default Product OS architecture map. Creates the template, layers, nodes, and flows. Safe to re-run \u2014 skips existing entries.",
+      annotations: { readOnlyHint: false }
+    },
+    async () => {
+      await ensureCollection();
+      const existing = await listArchEntries();
+      const existingIds = new Set(existing.map((e) => e.entryId));
+      let created = 0;
+      let updated = 0;
+      let unchanged = 0;
+      const allSeeds = [
+        { ...SEED_TEMPLATE, order: 0, status: "active" },
+        ...SEED_LAYERS.map((l) => ({ ...l, status: "active" })),
+        ...SEED_NODES.map((n) => ({ ...n, status: "active" })),
+        ...SEED_FLOWS.map((f) => ({ ...f, status: "active" }))
+      ];
+      for (const seed of allSeeds) {
+        if (existingIds.has(seed.entryId)) {
+          const existingEntry = existing.find((e) => e.entryId === seed.entryId);
+          const existingData = existingEntry?.data ?? {};
+          const seedData = seed.data;
+          const hasChanges = Object.keys(seedData).some(
+            (k) => seedData[k] !== void 0 && existingData[k] !== seedData[k]
+          );
+          if (hasChanges) {
+            const mergedData = { ...existingData, ...seedData };
+            await mcpMutation("kb.updateEntry", {
+              entryId: seed.entryId,
+              data: mergedData
+            });
+            updated++;
+          } else {
+            unchanged++;
+          }
+          continue;
         }
+        await mcpMutation("kb.createEntry", {
+          collectionSlug: COLLECTION_SLUG,
+          entryId: seed.entryId,
+          name: seed.name,
+          status: seed.status,
+          data: seed.data,
+          order: seed.order ?? 0
+        });
+        created++;
       }
       return {
-        contents: [{ uri: uri.href, text: `# Workspace Labels (${labels.length})
+        content: [{
+          type: "text",
+          text: `# Architecture Seeded
 
-${lines.join("\n")}`, mimeType: "text/markdown" }]
+**Created:** ${created} entries
+**Updated:** ${updated} (merged new fields)
+**Unchanged:** ${unchanged}
+
+Use \`show-architecture\` to view the map.`
+        }]
       };
     }
   );
-}
-
-// src/prompts/index.ts
-import { z as z6 } from "zod";
+  server2.registerTool(
+    "check-architecture",
+    {
+      title: "Check Architecture Health",
+      description: "Scan the codebase for dependency direction violations. Reads architecture layers, nodes, and their file paths from the knowledge base, then parses TypeScript/Svelte imports and checks them against the layer dependency rules (Auth \u2190 Infra \u2190 Core \u2190 Features; Integration \u2192 Core only). Returns a structured violation report.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const projectRoot = resolveProjectRoot2();
+      if (!projectRoot) {
+        return {
+          content: [{
+            type: "text",
+            text: "# Scan Failed\n\nCannot find project root (looked for `convex/schema.ts` in cwd and parent). Set `WORKSPACE_PATH` env var to the absolute path of the Product OS project root."
+          }]
+        };
+      }
+      await ensureCollection();
+      const all = await listArchEntries();
+      const layers = byTag(all, "layer");
+      const nodes = byTag(all, "node");
+      const result = scanDependencies(projectRoot, layers, nodes);
+      return {
+        content: [{
+          type: "text",
+          text: formatScanReport(result)
+        }]
+      };
+    }
+  );
+}
+function resolveProjectRoot2() {
+  const candidates = [
+    process.env.WORKSPACE_PATH,
+    process.cwd(),
+    resolve2(process.cwd(), "..")
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    const resolved = resolve2(dir);
+    if (existsSync2(resolve2(resolved, "convex/schema.ts"))) return resolved;
+  }
+  return null;
+}
+function scanDependencies(projectRoot, layers, nodes) {
+  const layerMap = /* @__PURE__ */ new Map();
+  for (const l of layers) layerMap.set(l.entryId, l);
+  const allowedDeps = buildAllowedDeps(layers);
+  const nodePathPrefixes = buildNodePrefixes(nodes);
+  const violations = [];
+  const nodeResults = /* @__PURE__ */ new Map();
+  let totalFiles = 0;
+  let totalImports = 0;
+  let unmapped = 0;
+  for (const node of nodes) {
+    const layerRef = String(node.data?.layerRef ?? "");
+    const layer = layerMap.get(layerRef);
+    if (!layer) continue;
+    const filePaths = parseFilePaths(node);
+    const nodeViolations = [];
+    let nodeFileCount = 0;
+    for (const fp of filePaths) {
+      const absPath = resolve2(projectRoot, fp);
+      const files = collectFiles(absPath);
+      for (const file of files) {
+        nodeFileCount++;
+        totalFiles++;
+        const relFile = relative(projectRoot, file);
+        const imports = parseImports(file);
+        for (const imp of imports) {
+          totalImports++;
+          const resolved = resolveImport(imp, file, projectRoot);
+          if (!resolved) {
+            unmapped++;
+            continue;
+          }
+          const targetNode = findNodeByPath(resolved, nodePathPrefixes);
+          if (!targetNode) {
+            unmapped++;
+            continue;
+          }
+          const targetLayerRef = String(targetNode.data?.layerRef ?? "");
+          const targetLayer = layerMap.get(targetLayerRef);
+          if (!targetLayer) continue;
+          if (targetLayerRef === layerRef) continue;
+          const allowed = allowedDeps.get(layerRef);
+          if (allowed && !allowed.has(targetLayerRef)) {
+            const v = {
+              sourceNode: node.name,
+              sourceLayer: layer.name,
+              sourceFile: relFile,
+              importPath: imp,
+              targetNode: targetNode.name,
+              targetLayer: targetLayer.name,
+              rule: `${layer.name} cannot import from ${targetLayer.name}`
+            };
+            violations.push(v);
+            nodeViolations.push(v);
+          }
+        }
+      }
+    }
+    nodeResults.set(node.entryId, { violations: nodeViolations, filesScanned: nodeFileCount });
+  }
+  return { violations, filesScanned: totalFiles, importsChecked: totalImports, unmappedImports: unmapped, nodeResults };
+}
+function buildAllowedDeps(layers) {
+  const nameToId = /* @__PURE__ */ new Map();
+  for (const l of layers) nameToId.set(l.name.toLowerCase(), l.entryId);
+  const allowed = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    const deps = String(layer.data?.dependsOn ?? "none");
+    const set = /* @__PURE__ */ new Set();
+    if (deps !== "none") {
+      for (const dep of deps.split(",").map((d) => d.trim().toLowerCase())) {
+        const id = nameToId.get(dep);
+        if (id) set.add(id);
+      }
+    }
+    allowed.set(layer.entryId, set);
+  }
+  return allowed;
+}
+function buildNodePrefixes(nodes) {
+  const entries = [];
+  for (const node of nodes) {
+    for (const fp of parseFilePaths(node)) {
+      entries.push({ prefix: normalize(fp), node });
+    }
+  }
+  entries.sort((a, b) => b.prefix.length - a.prefix.length);
+  return entries;
+}
+function parseFilePaths(node) {
+  const raw = node.data?.filePaths;
+  if (!raw || typeof raw !== "string") return [];
+  return raw.split(",").map((p) => p.trim()).filter(Boolean);
+}
+function collectFiles(absPath) {
+  if (!existsSync2(absPath)) return [];
+  const stat = statSync(absPath);
+  if (stat.isFile()) {
+    return isScannableFile(absPath) ? [absPath] : [];
+  }
+  if (!stat.isDirectory()) return [];
+  const results = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = resolve2(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (isScannableFile(full)) results.push(full);
+    }
+  };
+  walk(absPath);
+  return results;
+}
+function isScannableFile(p) {
+  return /\.(ts|js|svelte)$/.test(p) && !p.endsWith(".d.ts");
+}
+function parseImports(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const re = /(?:^|\n)\s*import\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+    const imports = [];
+    let match;
+    while ((match = re.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    return imports;
+  } catch {
+    return [];
+  }
+}
+var EXTENSIONS = [".ts", ".js", ".svelte", "/index.ts", "/index.js", "/index.svelte"];
+function tryResolveWithExtension(absPath) {
+  if (existsSync2(absPath) && statSync(absPath).isFile()) return absPath;
+  for (const ext of EXTENSIONS) {
+    const withExt = absPath + ext;
+    if (existsSync2(withExt)) return withExt;
+  }
+  return null;
+}
+function resolveImport(imp, fromFile, root) {
+  let rel = null;
+  if (imp.startsWith("$lib/")) rel = imp.replace("$lib/", "src/lib/");
+  else if (imp.startsWith("$convex/")) rel = imp.replace("$convex/", "convex/");
+  else if (imp.startsWith("$env/") || imp.startsWith("$app/")) return null;
+  else if (imp.startsWith("./") || imp.startsWith("../")) {
+    const fromDir = dirname(fromFile);
+    const abs2 = resolve2(fromDir, imp);
+    rel = relative(root, abs2);
+  }
+  if (!rel) return null;
+  const abs = resolve2(root, rel);
+  const actual = tryResolveWithExtension(abs);
+  return actual ? relative(root, actual) : rel;
+}
+function findNodeByPath(filePath, prefixes) {
+  const normalized = normalize(filePath);
+  for (const { prefix, node } of prefixes) {
+    if (normalized.startsWith(prefix)) return node;
+  }
+  return null;
+}
+function formatScanReport(result) {
+  const lines = [];
+  if (result.violations.length === 0) {
+    lines.push(
+      `# Architecture Health Check Passed`,
+      "",
+      `**0 violations** across ${result.filesScanned} files (${result.importsChecked} imports checked, ${result.unmappedImports} unmapped).`,
+      "",
+      "All imports respect the layer dependency rules."
+    );
+  } else {
+    lines.push(
+      `# Architecture Health Check \u2014 ${result.violations.length} Violation${result.violations.length === 1 ? "" : "s"}`,
+      "",
+      `Scanned ${result.filesScanned} files, checked ${result.importsChecked} imports, found **${result.violations.length} violation${result.violations.length === 1 ? "" : "s"}** (${result.unmappedImports} unmapped).`,
+      ""
+    );
+    const byNode = /* @__PURE__ */ new Map();
+    for (const v of result.violations) {
+      if (!byNode.has(v.sourceNode)) byNode.set(v.sourceNode, []);
+      byNode.get(v.sourceNode).push(v);
+    }
+    for (const [nodeName, vs] of byNode) {
+      lines.push(`## ${nodeName} (${vs[0].sourceLayer})`);
+      for (const v of vs) {
+        lines.push(`- \`${v.sourceFile}\` imports \`${v.importPath}\` \u2192 **${v.targetNode}** (${v.targetLayer}) \u2014 ${v.rule}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---", "");
+  const nodeEntries = [...result.nodeResults.entries()];
+  const cleanCount = nodeEntries.filter(([, r]) => r.violations.length === 0 && r.filesScanned > 0).length;
+  const dirtyCount = nodeEntries.filter(([, r]) => r.violations.length > 0).length;
+  const emptyCount = nodeEntries.filter(([, r]) => r.filesScanned === 0).length;
+  lines.push(
+    `**Summary:** ${cleanCount} clean nodes, ${dirtyCount} with violations, ${emptyCount} with no files.`
+  );
+  return lines.join("\n");
+}
+
+// src/tools/workflows.ts
+import { z as z7 } from "zod";
+
+// src/workflows/definitions.ts
+var RETRO_WORKFLOW = {
+  id: "retro",
+  name: "Retrospective",
+  shortDescription: "Structured team retrospective \u2014 reflect, surface patterns, commit to actions. Outputs a decision entry in the Knowledge Base.",
+  icon: "\u25CE",
+  facilitatorPreamble: `You are now in **Facilitator Mode**. You are not a coding assistant \u2014 you are a facilitator running a structured retrospective.
+
+## Your Behavior
+
+1. **Guide, don't solve.** Ask questions, reflect back, synthesize. Never jump to solutions.
+2. **One round at a time.** Complete each round fully before moving to the next. No skipping.
+3. **Use structured questions** (AskQuestion tool) for choices and multi-select. Use open conversation for reflection.
+4. **Create a Plan** at the start showing all rounds as tasks. Update it as you progress.
+5. **Synthesize between rounds.** After collecting input, reflect back what you heard before moving on.
+6. **Never go silent.** If something fails, say what happened and what to do next.
+7. **Capture to KB** at the end using the Product OS smart-capture tool.
+8. **Match the energy.** Be warm but structured. This is a ceremony, not a checklist.
+
+## Communication Style
+
+- Start each round with its number, name, and a brief instruction
+- Use quotes and emphasis to reflect back what the participant said
+- End each round with a brief synthesis before transitioning
+- When a round is complete, mark it as done in the Plan
+- If the participant seems stuck, offer prompts \u2014 never pressure
+- If a tool call fails, explain what happened and offer an alternative path
+
+## Error Recovery
+
+If at any point a tool call or MCP operation fails:
+1. Tell the participant what you were trying to do
+2. Explain what went wrong (briefly, no stack traces)
+3. Offer a manual alternative (e.g., "I'll capture this in the conversation instead")
+4. Continue the workflow \u2014 never halt completely
+
+## Plan Structure
+
+Create a Cursor Plan with these rounds as tasks. Mark each in_progress as you enter it, completed when done.`,
+  rounds: [
+    {
+      id: "set-stage",
+      num: "01",
+      label: "Set the Stage",
+      type: "choice",
+      instruction: "Before we dive in, let's frame what we're reflecting on. What's the scope of this retro?",
+      facilitatorGuidance: "Start warm. Ask the participant to pick or describe what they're retro-ing. Confirm the scope before proceeding. If they gave context already in their initial message, use it \u2014 don't make them repeat.",
+      questions: [
+        {
+          id: "scope",
+          prompt: "What are we reflecting on? Pick one or describe your own.",
+          options: [
+            { id: "last-week", label: "Last week's work" },
+            { id: "last-sprint", label: "Last sprint/cycle" },
+            { id: "specific-project", label: "A specific project or feature" },
+            { id: "process", label: "A process or workflow" },
+            { id: "custom", label: "Something else \u2014 let me describe it" }
+          ]
+        }
+      ],
+      outputSchema: {
+        field: "scope",
+        description: "What timeframe or project is being retro'd",
+        format: "freetext"
+      },
+      maxDurationHint: "2 min"
+    },
+    {
+      id: "what-went-well",
+      num: "02",
+      label: "What Went Well",
+      type: "open",
+      instruction: "Let's start with the good. What went well? What are you proud of? What should we do more of?",
+      facilitatorGuidance: "Celebrate. Reflect back each win with genuine emphasis. Ask follow-ups like 'What made that work?' or 'Who else contributed to that?' Collect at least 3 items before synthesizing. Don't rush past the positive \u2014 teams skip this too fast.",
+      outputSchema: {
+        field: "wentWell",
+        description: "List of things that went well",
+        format: "list"
+      },
+      maxDurationHint: "5 min"
+    },
+    {
+      id: "what-didnt-go-well",
+      num: "03",
+      label: "What Didn't Go Well",
+      type: "open",
+      instruction: "Now the harder part. What didn't go well? What frustrated you? Where did things break down?",
+      facilitatorGuidance: "Create safety. Acknowledge that this is harder. Don't judge or immediately problem-solve \u2014 just listen and capture. Ask 'What was the impact of that?' and 'When did you first notice it?'. Reflect back without softening. Collect at least 3 items.",
+      outputSchema: {
+        field: "didntGoWell",
+        description: "List of things that didn't go well",
+        format: "list"
+      },
+      maxDurationHint: "5 min"
+    },
+    {
+      id: "patterns",
+      num: "04",
+      label: "Patterns & Insights",
+      type: "synthesis",
+      instruction: "Looking at what went well and what didn't \u2014 what patterns do you see? What's the deeper insight?",
+      facilitatorGuidance: "This is YOUR moment as facilitator. Synthesize what you've heard across rounds 2 and 3. Surface themes, connections, and contradictions. Propose 2-3 patterns and ask the participant to react. This round transforms raw observations into actionable insights. Don't let the participant skip the 'why' \u2014 push for root causes.",
+      outputSchema: {
+        field: "patterns",
+        description: "Synthesized patterns and insights",
+        format: "structured"
+      },
+      maxDurationHint: "5 min"
+    },
+    {
+      id: "actions",
+      num: "05",
+      label: "Actions & Commitments",
+      type: "commit",
+      instruction: "Based on these patterns, what will we actually change? Be specific \u2014 who does what, by when?",
+      facilitatorGuidance: "Push for specificity. 'Be better at X' is not an action. 'Randy will set up a 15-min weekly check-in by Friday' is. Each action needs an owner and a deadline. Aim for 2-4 concrete actions. Use AskQuestion to confirm the final list. These become the retro's output.",
+      questions: [
+        {
+          id: "action-confirm",
+          prompt: "Are these actions concrete enough to actually happen?",
+          options: [
+            { id: "yes", label: "Yes \u2014 these are clear and actionable" },
+            { id: "refine", label: "Let me refine some of these" },
+            { id: "add", label: "I want to add more" }
+          ]
+        }
+      ],
+      outputSchema: {
+        field: "actions",
+        description: "Committed actions with owners and deadlines",
+        format: "structured"
+      },
+      maxDurationHint: "5 min"
+    },
+    {
+      id: "close",
+      num: "06",
+      label: "Close & Capture",
+      type: "close",
+      instruction: "One last thing \u2014 in one sentence, what's the single most important thing you're taking away from this retro?",
+      facilitatorGuidance: "Keep it brief. One sentence reflection. Then summarize the entire retro: scope, key wins, key pain points, patterns identified, actions committed. Ask if they want to save this to the Knowledge Base. If yes, use smart-capture to create a decision/tension entry. Thank them for the retro.",
+      outputSchema: {
+        field: "takeaway",
+        description: "Single-sentence takeaway",
+        format: "freetext"
+      },
+      kbCollection: "decisions",
+      maxDurationHint: "2 min"
+    }
+  ],
+  kbOutputCollection: "decisions",
+  kbOutputTemplate: {
+    nameTemplate: "Retro: {scope} \u2014 {date}",
+    descriptionField: "rationale"
+  },
+  errorRecovery: `If anything goes wrong during the retro:
+
+1. **MCP tool failure**: Skip the KB capture step. Summarize everything in the conversation instead. Suggest the participant runs \`smart-capture\` manually later.
+2. **AskQuestion not available**: Fall back to numbered options in plain text. "Reply with 1, 2, or 3."
+3. **Plan creation fails**: Continue without the Plan. The conversation IS the record.
+4. **Participant goes off-topic**: Gently redirect: "That's valuable \u2014 let's capture it. For now, let's stay with [current round]."
+5. **Participant wants to stop**: Respect it. Summarize what you have so far. Offer to save partial results to KB.
+
+The retro must never fail silently. Always communicate state.`
+};
+var WORKFLOWS = /* @__PURE__ */ new Map([
+  ["retro", RETRO_WORKFLOW]
+]);
+function getWorkflow(id) {
+  return WORKFLOWS.get(id);
+}
+function listWorkflows() {
+  return Array.from(WORKFLOWS.values());
+}
+
+// src/tools/workflows.ts
+function formatWorkflowCard(wf) {
+  const roundList = wf.rounds.map((r) => `  ${r.num}. ${r.label} (${r.type}, ~${r.maxDurationHint ?? "?"})`).join("\n");
+  return `## ${wf.icon} ${wf.name}
+**ID**: \`${wf.id}\`
+${wf.shortDescription}
+
+**Rounds** (${wf.rounds.length}):
+${roundList}
+
+**Output**: Creates entries in \`${wf.kbOutputCollection}\` collection.
+_Use the \`run-workflow\` prompt with workflow="${wf.id}" to start._`;
+}
+function registerWorkflowTools(server2) {
+  server2.registerTool(
+    "list-workflows",
+    {
+      title: "List Workflows",
+      description: "List all available Chainwork workflows \u2014 retro, shape-a-bet, IDM, etc. Each workflow is a structured multi-round facilitation ceremony that the agent runs in Facilitator Mode. Use the `run-workflow` prompt to actually launch one.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const workflows = listWorkflows();
+      if (workflows.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No workflows registered yet. Check back after the workflow definitions are configured."
+          }]
+        };
+      }
+      const cards = workflows.map(formatWorkflowCard).join("\n\n---\n\n");
+      return {
+        content: [{
+          type: "text",
+          text: `# Available Chainwork Workflows
+
+${workflows.length} workflow(s) available. Use the \`run-workflow\` prompt to launch one.
+
+---
+
+${cards}`
+        }]
+      };
+    }
+  );
+  server2.registerTool(
+    "workflow-checkpoint",
+    {
+      title: "Workflow Checkpoint",
+      description: "Record the output of a workflow round. Captures the round's data to the Knowledge Base as a structured entry. Use this during Facilitator Mode after completing each round to persist progress \u2014 so if the conversation is interrupted, work is not lost.\n\nAt workflow completion, this tool can also generate the final summary entry.",
+      inputSchema: {
+        workflowId: z7.string().describe("Workflow ID (e.g., 'retro')"),
+        roundId: z7.string().describe("Round ID (e.g., 'what-went-well')"),
+        output: z7.string().describe("The round's output \u2014 synthesized by the facilitator from the conversation"),
+        isFinal: z7.boolean().optional().describe(
+          "If true, this is the final checkpoint and triggers the summary KB entry creation"
+        ),
+        summaryName: z7.string().optional().describe(
+          "Name for the final KB entry (required when isFinal=true)"
+        ),
+        summaryDescription: z7.string().optional().describe(
+          "Full description/rationale for the final KB entry (required when isFinal=true)"
+        )
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ workflowId, roundId, output, isFinal, summaryName, summaryDescription }) => {
+      const wf = getWorkflow(workflowId);
+      if (!wf) {
+        return {
+          content: [{
+            type: "text",
+            text: `Workflow "${workflowId}" not found. Available: ${listWorkflows().map((w) => w.id).join(", ")}.
+
+This checkpoint was NOT saved. Continue the conversation \u2014 the facilitator has the context.`
+          }]
+        };
+      }
+      const round = wf.rounds.find((r) => r.id === roundId);
+      if (!round) {
+        return {
+          content: [{
+            type: "text",
+            text: `Round "${roundId}" not found in workflow "${workflowId}". Available rounds: ${wf.rounds.map((r) => r.id).join(", ")}.
+
+This checkpoint was NOT saved. The conversation context is preserved \u2014 continue facilitating.`
+          }]
+        };
+      }
+      const lines = [
+        `## Checkpoint: Round ${round.num} \u2014 ${round.label}`,
+        `Workflow: ${wf.name} (\`${wf.id}\`)`,
+        ""
+      ];
+      if (isFinal && summaryName && summaryDescription) {
+        try {
+          const entryId = await mcpMutation("kb.createEntry", {
+            collectionSlug: wf.kbOutputCollection,
+            name: summaryName,
+            status: "draft",
+            data: {
+              [wf.kbOutputTemplate.descriptionField]: summaryDescription,
+              workflowType: wf.id,
+              completedRound: roundId,
+              date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+            },
+            createdBy: `workflow:${wf.id}`
+          });
+          lines.push(
+            `**KB Entry Created**: \`${entryId}\``,
+            `Collection: \`${wf.kbOutputCollection}\``,
+            `Name: ${summaryName}`,
+            "",
+            `The retro is now captured in the Knowledge Base. `,
+            `Use \`suggest-links\` on this entry to connect it to related knowledge.`
+          );
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          lines.push(
+            `**KB capture failed**: ${msg}`,
+            "",
+            `The retro output is preserved in this conversation. `,
+            `You can manually create the entry later using \`smart-capture\` with:`,
+            `- Collection: \`${wf.kbOutputCollection}\``,
+            `- Name: ${summaryName}`,
+            `- Description: (copy from the conversation summary above)`
+          );
+        }
+      } else {
+        lines.push(
+          `Round ${round.num} output recorded.`,
+          `Output: ${output.substring(0, 200)}${output.length > 200 ? "..." : ""}`
+        );
+        const currentIdx = wf.rounds.findIndex((r) => r.id === roundId);
+        if (currentIdx < wf.rounds.length - 1) {
+          const next = wf.rounds[currentIdx + 1];
+          lines.push(
+            "",
+            `**Next**: Round ${next.num} \u2014 ${next.label}`,
+            `_${next.instruction}_`
+          );
+        } else {
+          lines.push(
+            "",
+            `**All rounds complete.** Call this tool again with \`isFinal: true\` to create the KB entry.`
+          );
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+
+// src/tools/gitchain.ts
+import { z as z8 } from "zod";
+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");
+}
+function registerGitChainTools(server2) {
+  server2.registerTool(
+    "chain-create",
+    {
+      title: "Create Chain",
+      description: "Create a new strategic chain in the knowledge base. Chains are versioned knowledge artifacts that follow a chain type definition (e.g. Strategy Coherence: Problem \u2192 Insight \u2192 Choice \u2192 Action \u2192 Outcome). Returns the chain's entry ID for subsequent operations.",
+      inputSchema: {
+        title: z8.string().describe("Title for the chain, e.g. 'Q1 Growth Strategy'"),
+        chainTypeId: z8.string().default("strategy-coherence").describe(
+          "Chain type ID. Use 'strategy-coherence' for 5-link strategy chains (Problem \u2192 Insight \u2192 Choice \u2192 Action \u2192 Outcome) or 'idm-proposal' for IDM governance chains (Tension \u2192 Proposal \u2192 Objections \u2192 Integration \u2192 Decision)"
+        ),
+        description: z8.string().optional().describe("Optional description of what this chain is about"),
+        author: z8.string().optional().describe("Who is creating this chain (clerkUserId or person name). Defaults to 'mcp'.")
+      }
+    },
+    async ({ title, chainTypeId, description, author }) => {
+      const result = await mcpMutation(
+        "gitchain.createChain",
+        { title, chainTypeId, description, author }
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# Chain Created
+
+- **Entry ID:** \`${result.entryId}\`
+- **Title:** ${title}
+- **Type:** ${chainTypeId}
+- **Status:** draft
+
+Use \`chain-edit\` with chainEntryId=\`${result.entryId}\` to start filling in links.`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-get",
+    {
+      title: "Get Chain",
+      description: "Retrieve a chain by its entry ID. Returns the full chain content, coherence scores, link fill status, and version info. Use chain-list first to discover chain entry IDs.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ chainEntryId }) => {
+      const chain = await mcpQuery("gitchain.getChain", { chainEntryId });
+      if (!chain) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Chain "${chainEntryId}" not found.`
+            }
+          ]
+        };
+      }
+      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") : "";
+      const text = `# ${chain.name}
+
+- **Entry ID:** \`${chain.entryId}\`
+- **Type:** ${chain.chainTypeName}
+- **Status:** ${chain.status}
+- **Links filled:** ${chain.filledCount}/${chain.totalCount}
+- **Version:** ${chain.currentVersion}
+- **Created by:** ${chain.createdBy ?? "unknown"}
+- **History events:** ${chain.historyCount}
+` + scoreSection + `
+
+## Links
+
+` + linkSummary(chain.links);
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server2.registerTool(
+    "chain-edit",
+    {
+      title: "Edit Chain Link",
+      description: "Edit a specific link in a chain. Each chain has named links (e.g. for strategy-coherence: problem, insight, choice, action, outcome). The link content is replaced entirely \u2014 pass the full new text.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
+        linkId: z8.string().describe(
+          "Which link to edit. For strategy-coherence: problem, insight, choice, action, outcome. For idm-proposal: tension, proposal, objections, integration, decision."
+        ),
+        content: z8.string().describe("The full new content for this link"),
+        author: z8.string().optional().describe("Who is making this edit. Defaults to 'mcp'.")
+      }
+    },
+    async ({ chainEntryId, linkId, content, author }) => {
+      const result = await mcpMutation("gitchain.editLink", { chainEntryId, linkId, content, author });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# Link Updated
+
+- **Chain:** \`${result.entryId}\`
+- **Link:** ${result.linkId}
+- **Chain status:** ${result.status}
+- **Content length:** ${content.length} chars
+
+Use \`chain-get\` to see the full chain with updated scores.`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-list",
+    {
+      title: "List Chains",
+      description: "List all chains in the workspace, optionally filtered by chain type or status. Returns entry IDs, titles, link fill progress, and coherence scores.",
+      inputSchema: {
+        chainTypeId: z8.string().optional().describe("Filter by chain type: 'strategy-coherence' or 'idm-proposal'"),
+        status: z8.string().optional().describe("Filter by status: 'draft' or 'active'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ chainTypeId, status }) => {
+      const chains = await mcpQuery("gitchain.listChains", {
+        chainTypeId,
+        status
+      });
+      if (chains.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No chains found. Use `chain-create` to create one."
+            }
+          ]
+        };
+      }
+      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}`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-history",
+    {
+      title: "Chain History",
+      description: "View the edit history of a chain \u2014 all creation, update, and version events. Shows who changed what and when.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ chainEntryId }) => {
+      const history = await mcpQuery("gitchain.getHistory", {
+        chainEntryId
+      });
+      if (history.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No history found for chain "${chainEntryId}".`
+            }
+          ]
+        };
+      }
+      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}`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-commit",
+    {
+      title: "Commit Chain",
+      description: "Create a version snapshot (commit) of the current chain state. Records all link content, computes coherence score, and tracks which links changed. Commit messages should follow: type(link): description. Types: edit, refine, rewrite, integrate, revert.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
+        commitMessage: z8.string().describe(
+          "Commit message following convention: type(link): description. Example: 'edit(outcome): Add Q1 revenue target'"
+        ),
+        author: z8.string().optional().describe("Who is committing. Defaults to 'mcp'.")
+      }
+    },
+    async ({ chainEntryId, commitMessage, author }) => {
+      const result = await mcpMutation("gitchain.commitChain", { chainEntryId, commitMessage, author });
+      const warning = result.commitLintWarning ? `
+
+> **Lint warning:** ${result.commitLintWarning}` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# Committed v${result.version}
+
+- **Chain:** \`${result.entryId}\`
+- **Version:** ${result.version}
+- **Message:** ${commitMessage}
+- **Coherence:** ${result.coherenceScore}%
+- **Links modified:** ${result.linksModified.length > 0 ? result.linksModified.join(", ") : "none"}
+` + warning
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-commits",
+    {
+      title: "List Chain Commits",
+      description: "List all version snapshots (commits) for a chain, newest first. Shows version number, commit message, author, which links were modified, and status.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ chainEntryId }) => {
+      const commits = await mcpQuery("gitchain.listCommits", {
+        chainEntryId
+      });
+      if (commits.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No commits found for chain "${chainEntryId}". Use \`chain-commit\` to create the first snapshot.`
+            }
+          ]
+        };
+      }
+      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 && 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}`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-diff",
+    {
+      title: "Diff Chain Versions",
+      description: "Compare two versions of a chain. Shows which links changed, word-level diffs for modified links, and the coherence score delta. Use chain-commits first to see available version numbers.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
+        versionA: z8.number().describe("The earlier version number"),
+        versionB: z8.number().describe("The later version number")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ chainEntryId, versionA, versionB }) => {
+      const diff = await mcpMutation("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 && 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 }] };
+    }
+  );
+  server2.registerTool(
+    "chain-gate",
+    {
+      title: "Chain Coherence Gate",
+      description: "Run the coherence gate on a chain. Checks: coherence score >= 70%, all links filled, commit message follows convention. Returns pass/fail with detailed check results. This is the same gate that blocks publishing.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
+        commitMessage: z8.string().optional().describe("Optional commit message to lint")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ chainEntryId, commitMessage }) => {
+      const gate = await mcpQuery("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}`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-branch",
+    {
+      title: "Create or List Chain Branches",
+      description: "Create a new branch for isolated editing, or list all branches on a chain. Branches fork from the current published version of main. Use chain-merge to merge a branch back.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
+        action: z8.enum(["create", "list"]).describe("'create' to make a new branch, 'list' to see all branches"),
+        name: z8.string().optional().describe("Branch name for 'create' action. Auto-generated if not provided."),
+        author: z8.string().optional().describe("Who is creating the branch. Defaults to 'mcp'.")
+      }
+    },
+    async ({ chainEntryId, action, name, author }) => {
+      if (action === "create") {
+        const result = await mcpMutation("gitchain.createBranch", { chainEntryId, name, author });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Branch Created
+
+- **Name:** ${result.name}
+- **Based on:** v${result.baseVersion}
+- **Chain:** \`${chainEntryId}\`
+
+Edit links and commit on this branch, then use \`chain-merge\` to land changes.`
+            }
+          ]
+        };
+      }
+      const branches = await mcpMutation("gitchain.listBranches", {
+        chainEntryId
+      });
+      if (branches.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No branches found for chain "${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}`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-conflicts",
+    {
+      title: "Check Branch Conflicts",
+      description: "Check if a branch has conflicts with other active branches. Conflicts occur when two branches modify the same chain link. Always check before merging.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID"),
+        branchName: z8.string().describe("The branch name to check for conflicts")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ chainEntryId, branchName }) => {
+      const result = await mcpMutation("gitchain.checkConflicts", {
+        chainEntryId,
+        branchName
+      });
+      if (!result.hasConflicts) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# No Conflicts
+
+Branch "${branchName}" on \`${chainEntryId}\` has no conflicts with other active branches. Safe to merge.`
+            }
+          ]
+        };
+      }
+      const conflictLines = result.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. One branch must update its link content to avoid overwriting.`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-merge",
+    {
+      title: "Merge Branch",
+      description: "Merge a branch back into main. Runs the coherence gate before merging. The branch is closed after merge. Check for conflicts with chain-conflicts first.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID"),
+        branchName: z8.string().describe("The branch to merge"),
+        strategy: z8.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) preserves history, 'squash' collapses into one version"),
+        author: z8.string().optional().describe("Who is merging. Defaults to 'mcp'.")
+      }
+    },
+    async ({ chainEntryId, branchName, strategy, author }) => {
+      const result = await mcpMutation("gitchain.mergeBranch", {
+        chainEntryId,
+        branchName,
+        strategy,
+        author
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# Branch Merged
+
+- **Chain:** \`${result.entryId}\`
+- **Branch:** ${result.branchName} (now closed)
+- **Version:** v${result.version}
+- **Strategy:** ${result.strategy}
+
+Main is now at v${result.version}. The branch has been closed.`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-comment",
+    {
+      title: "Comment on Chain Version",
+      description: "Add a threaded comment on a specific chain version, optionally targeting a specific link. Comments support threading via parentId. Use chain-comments to see existing comments.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID"),
+        action: z8.enum(["add", "resolve", "list"]).describe("'add' a comment, 'resolve' a comment, or 'list' all comments"),
+        versionNumber: z8.number().optional().describe("Version number to comment on (required for 'add')"),
+        linkId: z8.string().optional().describe("Which link this comment targets (optional)"),
+        body: z8.string().optional().describe("Comment text (required for 'add')"),
+        commentId: z8.string().optional().describe("Comment ID to resolve (required for 'resolve')"),
+        author: z8.string().optional().describe("Who is commenting. Defaults to 'mcp'.")
+      }
+    },
+    async ({ chainEntryId, action, versionNumber, linkId, body, commentId, author }) => {
+      if (action === "add") {
+        if (!versionNumber) throw new Error("versionNumber is required for 'add'");
+        if (!body) throw new Error("body is required for 'add'");
+        const result = await mcpMutation("gitchain.addComment", {
+          chainEntryId,
+          versionNumber,
+          linkId,
+          body,
+          author
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Comment Added
+
+- **Chain:** \`${result.chainEntryId}\`
+- **Version:** v${result.versionNumber}
+` + (result.linkId ? `- **Link:** ${result.linkId}
+` : "") + `- **Body:** ${body?.substring(0, 200)}`
+            }
+          ]
+        };
+      }
+      if (action === "resolve") {
+        if (!commentId) throw new Error("commentId is required for 'resolve'");
+        await mcpMutation("gitchain.resolveComment", { commentId });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Comment resolved.`
+            }
+          ]
+        };
+      }
+      const comments = await mcpMutation("gitchain.listComments", {
+        chainEntryId,
+        versionNumber
+      });
+      if (comments.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No comments found for chain "${chainEntryId}"${versionNumber ? ` v${versionNumber}` : ""}.`
+            }
+          ]
+        };
+      }
+      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}`
+          }
+        ]
+      };
+    }
+  );
+  server2.registerTool(
+    "chain-revert",
+    {
+      title: "Revert Chain",
+      description: "Safely revert a chain to a previous version. Creates a NEW version that restores the content of the target version \u2014 history is preserved, nothing is destroyed. Use chain-commits to see available versions.",
+      inputSchema: {
+        chainEntryId: z8.string().describe("The chain's entry ID"),
+        toVersion: z8.number().describe("The version number to revert to"),
+        author: z8.string().optional().describe("Who is reverting. Defaults to 'mcp'.")
+      }
+    },
+    async ({ chainEntryId, toVersion, author }) => {
+      const result = await mcpMutation("gitchain.revertChain", { chainEntryId, toVersion, author });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# Reverted
+
+- **Chain:** \`${result.entryId}\`
+- **Reverted to:** v${result.revertedTo}
+- **New version:** v${result.newVersion}
+- **Links affected:** ${result.linksModified.length > 0 ? result.linksModified.join(", ") : "none"}
+
+History is preserved \u2014 this created a new version, not a destructive reset.`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/index.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function formatEntryMarkdown(entry) {
+  const id = entry.entryId ? `${entry.entryId}: ` : "";
+  const lines = [`## ${id}${entry.name} [${entry.status}]`];
+  if (entry.data && typeof entry.data === "object") {
+    for (const [key, val] of Object.entries(entry.data)) {
+      if (val && key !== "rawData") {
+        lines.push(`**${key}**: ${typeof val === "string" ? val : JSON.stringify(val)}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function buildOrientationMarkdown(collections, trackingEvents, standards, businessRules) {
+  const sections = ["# Product Brain \u2014 Orientation"];
+  sections.push(
+    "## Architecture\n```\nCursor (stdio) \u2192 MCP Server (mcp-server/src/index.ts)\n  \u2192 POST /api/mcp with Bearer token\n  \u2192 Convex HTTP Action (convex/http.ts)\n  \u2192 internalQuery / internalMutation (convex/mcpKnowledge.ts)\n  \u2192 Convex DB (workspace-scoped)\n```\nSecurity: API key auth on every request, workspace-scoped data, internal functions blocked from external clients.\nKey files: `packages/mcp-server/src/client.ts` (HTTP client + audit), `convex/schema.ts` (schema)."
+  );
+  if (collections) {
+    const collList = collections.map((c) => {
+      const prefix = c.icon ? `${c.icon} ` : "";
+      return `- ${prefix}**${c.name}** (\`${c.slug}\`) \u2014 ${c.description || "no description"}`;
+    }).join("\n");
+    sections.push(
+      `## Data Model (${collections.length} collections)
+Unified entries model: collections define field schemas, entries hold data in a flexible \`data\` field.
+Tags for filtering (e.g. \`severity:high\`), relations via \`entryRelations\`, history via \`entryHistory\`, labels via \`labels\` + \`entryLabels\`.
+
+` + collList + "\n\nUse `list-collections` for field schemas, `get-entry` for full records."
+    );
+  } else {
+    sections.push(
+      "## Data Model\nCould not load collections \u2014 use `list-collections` to browse manually."
+    );
+  }
+  const rulesCount = businessRules ? `${businessRules.length} entries` : "not loaded \u2014 collection may not exist yet";
+  sections.push(
+    `## Business Rules
+Collection: \`business-rules\` (${rulesCount}).
+Find rules: \`kb-search\` for text search, \`list-entries collection=business-rules\` to browse.
+Check compliance: use the \`review-against-rules\` prompt (pass a domain).
+Draft a new rule: use the \`draft-rule-from-context\` prompt.`
+  );
+  const eventsCount = trackingEvents ? `${trackingEvents.length} events` : "not loaded \u2014 collection may not exist yet";
+  const conventionNote = standards ? "Naming convention: `object_action` in snake_case with past-tense verbs (from standards collection)." : "Naming convention: `object_action` in snake_case with past-tense verbs.";
+  sections.push(
+    `## Analytics & Tracking
+Event catalog: \`tracking-events\` collection (${eventsCount}).
+${conventionNote}
+Implementation: \`src/lib/analytics.ts\`. Workspace-scoped events MUST use \`withWorkspaceGroup()\`.
+Browse: \`list-entries collection=tracking-events\`. Full setup: \`docs/posthog-setup.md\`.`
+  );
+  sections.push(
+    "## Knowledge Graph\nEntries are connected via typed relations (`entryRelations` table). Relations are bidirectional and collection-agnostic \u2014 any entry can link to any other entry.\n\n**Recommended relation types** (extensible \u2014 any string accepted):\n- `governs` \u2014 a rule constrains behavior of a feature\n- `defines_term_for` \u2014 a glossary term is canonical vocabulary for a feature/area\n- `belongs_to` \u2014 a feature belongs to a product area or parent concept\n- `informs` \u2014 a decision or insight informs a feature\n- `surfaces_tension_in` \u2014 a tension exists within a feature area\n- `related_to`, `depends_on`, `replaces`, `conflicts_with`, `references`, `confused_with`\n\nEach relation type is defined as a glossary entry (prefix `GT-REL-*`) to prevent terminology drift.\n\n**Tools:**\n- `gather-context` \u2014 get the full context around any entry (multi-hop graph traversal)\n- `suggest-links` \u2014 discover potential connections for an entry\n- `relate-entries` \u2014 create a typed link between two entries\n- `find-related` \u2014 list direct relations for an entry\n\n**Convention:** When creating or updating entries in governed collections, always use `suggest-links` to discover and create relevant relations."
+  );
+  sections.push(
+    "## Creating Knowledge\nUse `smart-capture` as the primary tool for creating new entries. It handles the full workflow in one call:\n1. Creates the entry with collection-aware defaults (auto-fills dates, infers domains, sets priority)\n2. Auto-links related entries from across the knowledge base (up to 5 confident matches)\n3. Returns a quality scorecard (X/10) with actionable improvement suggestions\n\n**Smart profiles** exist for: `tensions`, `business-rules`, `glossary`, `decisions`.\nAll other collections use sensible defaults.\n\nExample: `smart-capture collection='tensions' name='...' description='...'`\n\nUse `quality-check` to score existing entries retroactively.\nUse `create-entry` only when you need full control over every field.\nUse `quick-capture` for minimal ceremony without auto-linking."
+  );
+  sections.push(
+    "## Where to Go Next\n- **Create entry** \u2192 `smart-capture` tool (auto-links + quality score in one call)\n- **Full context** \u2192 `gather-context` tool (start here when working on a feature)\n- **Discover links** \u2192 `suggest-links` tool\n- **Quality audit** \u2192 `quality-check` tool\n- **Terminology** \u2192 `name-check` prompt or `productbrain://terminology` resource\n- **Schema details** \u2192 `productbrain://collections` resource or `list-collections` tool\n- **Labels** \u2192 `productbrain://labels` resource or `list-labels` tool\n- **Any collection** \u2192 `productbrain://{slug}/entries` resource\n- **Log a decision** \u2192 `draft-decision-record` prompt\n- **Architecture map** \u2192 `show-architecture` tool (layered system visualization)\n- **Explore a layer** \u2192 `explore-layer` tool (drill into Auth, Core, Features, etc.)\n- **Health check** \u2192 `health` tool\n- **Debug MCP calls** \u2192 `mcp-audit` tool"
+  );
+  return sections.join("\n\n---\n\n");
+}
+function registerResources(server2) {
+  server2.resource(
+    "kb-orientation",
+    "productbrain://orientation",
+    async (uri) => {
+      const [collectionsResult, eventsResult, standardsResult, rulesResult] = await Promise.allSettled([
+        mcpQuery("kb.listCollections"),
+        mcpQuery("kb.listEntries", { collectionSlug: "tracking-events" }),
+        mcpQuery("kb.listEntries", { collectionSlug: "standards" }),
+        mcpQuery("kb.listEntries", { collectionSlug: "business-rules" })
+      ]);
+      const collections = collectionsResult.status === "fulfilled" ? collectionsResult.value : null;
+      const trackingEvents = eventsResult.status === "fulfilled" ? eventsResult.value : null;
+      const standards = standardsResult.status === "fulfilled" ? standardsResult.value : null;
+      const businessRules = rulesResult.status === "fulfilled" ? rulesResult.value : null;
+      return {
+        contents: [{
+          uri: uri.href,
+          text: buildOrientationMarkdown(collections, trackingEvents, standards, businessRules),
+          mimeType: "text/markdown"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "kb-terminology",
+    "productbrain://terminology",
+    async (uri) => {
+      const [glossaryResult, standardsResult] = await Promise.allSettled([
+        mcpQuery("kb.listEntries", { collectionSlug: "glossary" }),
+        mcpQuery("kb.listEntries", { collectionSlug: "standards" })
+      ]);
+      const lines = ["# Product Brain \u2014 Terminology"];
+      if (glossaryResult.status === "fulfilled") {
+        if (glossaryResult.value.length > 0) {
+          const terms = glossaryResult.value.map((t) => `- **${t.name}** (${t.entryId ?? "\u2014"}) [${t.status}]: ${t.data?.canonical ?? t.data?.description ?? ""}`).join("\n");
+          lines.push(`## Glossary (${glossaryResult.value.length} terms)
+
+${terms}`);
+        } else {
+          lines.push("## Glossary\n\nNo glossary terms yet. Use `create-entry` with collection `glossary` to add terms.");
+        }
+      } else {
+        lines.push("## Glossary\n\nCould not load glossary \u2014 use `list-entries collection=glossary` to browse manually.");
+      }
+      if (standardsResult.status === "fulfilled") {
+        if (standardsResult.value.length > 0) {
+          const stds = standardsResult.value.map((s) => `- **${s.name}** (${s.entryId ?? "\u2014"}) [${s.status}]: ${s.data?.description ?? ""}`).join("\n");
+          lines.push(`## Standards (${standardsResult.value.length} entries)
+
+${stds}`);
+        } else {
+          lines.push("## Standards\n\nNo standards yet. Use `create-entry` with collection `standards` to add standards.");
+        }
+      } else {
+        lines.push("## Standards\n\nCould not load standards \u2014 use `list-entries collection=standards` to browse manually.");
+      }
+      return {
+        contents: [{ uri: uri.href, text: lines.join("\n\n---\n\n"), mimeType: "text/markdown" }]
+      };
+    }
+  );
+  server2.resource(
+    "kb-collections",
+    "productbrain://collections",
+    async (uri) => {
+      const collections = await mcpQuery("kb.listCollections");
+      if (collections.length === 0) {
+        return { contents: [{ uri: uri.href, text: "No collections in this workspace.", mimeType: "text/markdown" }] };
+      }
+      const formatted = collections.map((c) => {
+        const fieldList = c.fields.map((f) => `  - \`${f.key}\` (${f.type}${f.required ? ", required" : ""}${f.searchable ? ", searchable" : ""})`).join("\n");
+        return `## ${c.icon ?? ""} ${c.name} (\`${c.slug}\`)
+${c.description || ""}
+
+**Fields:**
+${fieldList}`;
+      }).join("\n\n---\n\n");
+      return {
+        contents: [{ uri: uri.href, text: `# Knowledge Collections (${collections.length})
+
+${formatted}`, mimeType: "text/markdown" }]
+      };
+    }
+  );
+  server2.resource(
+    "kb-collection-entries",
+    new ResourceTemplate("productbrain://{slug}/entries", {
+      list: async () => {
+        const collections = await mcpQuery("kb.listCollections");
+        return {
+          resources: collections.map((c) => ({
+            uri: `productbrain://${c.slug}/entries`,
+            name: `${c.icon ?? ""} ${c.name}`.trim()
+          }))
+        };
+      }
+    }),
+    async (uri, { slug }) => {
+      const entries = await mcpQuery("kb.listEntries", { collectionSlug: slug });
+      const formatted = entries.map(formatEntryMarkdown).join("\n\n---\n\n");
+      return {
+        contents: [{
+          uri: uri.href,
+          text: formatted || "No entries in this collection.",
+          mimeType: "text/markdown"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "kb-labels",
+    "productbrain://labels",
+    async (uri) => {
+      const labels = await mcpQuery("kb.listLabels");
+      if (labels.length === 0) {
+        return { contents: [{ uri: uri.href, text: "No labels in this workspace.", mimeType: "text/markdown" }] };
+      }
+      const groups = labels.filter((l) => l.isGroup);
+      const ungrouped = labels.filter((l) => !l.isGroup && !l.parentId);
+      const children = (parentId) => labels.filter((l) => l.parentId === parentId);
+      const lines = [];
+      for (const group of groups) {
+        lines.push(`## ${group.name}`);
+        for (const child of children(group._id)) {
+          lines.push(`- \`${child.slug}\` ${child.name}${child.color ? ` (${child.color})` : ""}`);
+        }
+      }
+      if (ungrouped.length > 0) {
+        lines.push("## Ungrouped");
+        for (const l of ungrouped) {
+          lines.push(`- \`${l.slug}\` ${l.name}${l.color ? ` (${l.color})` : ""}`);
+        }
+      }
+      return {
+        contents: [{ uri: uri.href, text: `# Workspace Labels (${labels.length})
+
+${lines.join("\n")}`, mimeType: "text/markdown" }]
+      };
+    }
+  );
+}
+
+// src/prompts/index.ts
+import { z as z9 } from "zod";
 function registerPrompts(server2) {
   server2.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: z6.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z9.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
     async ({ domain }) => {
       const entries = await mcpQuery("kb.listEntries", { collectionSlug: "business-rules" });
       const rules = entries.filter((e) => e.data?.domain === domain);
@@ -2343,7 +3934,7 @@ Provide a structured review with a compliance status for each rule (COMPLIANT /
   server2.prompt(
     "name-check",
     "Check variable names, field names, or API names against the glossary for terminology alignment. Flags drift from canonical terms.",
-    { names: z6.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z9.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
     async ({ names }) => {
       const terms = await mcpQuery("kb.listEntries", { collectionSlug: "glossary" });
       const glossaryContext = terms.map(
@@ -2379,7 +3970,7 @@ Format as a table: Name | Status | Canonical Form | Action Needed`
   server2.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: z6.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z9.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 mcpQuery("kb.listEntries", { collectionSlug: "decisions" });
       const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
@@ -2417,8 +4008,8 @@ After drafting, I can log it using the create-entry tool with collection "decisi
     "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: z6.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
-      domain: z6.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z9.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z9.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
     },
     async ({ observation, domain }) => {
       const allRules = await mcpQuery("kb.listEntries", { collectionSlug: "business-rules" });
@@ -2459,13 +4050,120 @@ Make sure the rule is consistent with existing rules and doesn't contradict them
       };
     }
   );
+  server2.prompt(
+    "run-workflow",
+    "Launch a Chainwork workflow (retro, shape, IDM) in Facilitator Mode. Returns the full workflow definition, facilitation instructions, and round structure. The agent enters Facilitator Mode and guides the participant through each round.",
+    {
+      workflow: z9.string().describe(
+        "Workflow ID to run. Available: " + listWorkflows().map((w) => `'${w.id}' (${w.name})`).join(", ")
+      ),
+      context: z9.string().optional().describe(
+        "Optional context from the participant (e.g., 'retro on last sprint', 'shape the Chainwork API bet')"
+      )
+    },
+    async ({ workflow: workflowId, context }) => {
+      const wf = getWorkflow(workflowId);
+      if (!wf) {
+        const available = listWorkflows().map((w) => `- **${w.id}**: ${w.name} \u2014 ${w.shortDescription}`).join("\n");
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `Workflow "${workflowId}" not found.
+
+Available workflows:
+${available}
+
+Use one of these IDs to run a workflow.`
+              }
+            }
+          ]
+        };
+      }
+      let kbContext = "";
+      try {
+        const recentDecisions = await mcpQuery("kb.listEntries", {
+          collectionSlug: wf.kbOutputCollection
+        });
+        const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
+        if (sorted.length > 0) {
+          kbContext = `
+## Recent ${wf.kbOutputCollection} entries (for context)
+` + sorted.map((d) => `- ${d.entryId ?? ""}: ${d.name} [${d.status}]`).join("\n");
+        }
+      } catch {
+        kbContext = "\n_Could not load KB context \u2014 proceed without it._";
+      }
+      const roundsPlan = wf.rounds.map(
+        (r) => `### Round ${r.num}: ${r.label}
+**Type**: ${r.type} | **Duration**: ~${r.maxDurationHint ?? "5 min"}
+**Instruction**: ${r.instruction}
+**Facilitator guidance**: ${r.facilitatorGuidance}
+` + (r.questions ? r.questions.map(
+          (q) => `**Question**: ${q.prompt}
+` + (q.options ? q.options.map((o) => `  - ${o.id}: ${o.label}`).join("\n") : "  _(open response)_")
+        ).join("\n") : "") + `
+**Output**: Capture to \`${r.outputSchema.field}\` (${r.outputSchema.format})`
+      ).join("\n\n---\n\n");
+      const contextLine = context ? `
+The participant provided this context: "${context}"
+Use it \u2014 don't make them repeat themselves.
+` : "";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `# ${wf.icon} ${wf.name} Workflow \u2014 Facilitator Mode
+
+${wf.shortDescription}
+` + contextLine + `
+---
+
+## Facilitator Instructions
+
+${wf.facilitatorPreamble}
+
+---
+
+## Rounds
+
+${roundsPlan}
+
+---
+
+## Error Recovery
+
+${wf.errorRecovery}
+
+---
+
+## KB Output
+
+When complete, use \`smart-capture\` to create a \`${wf.kbOutputCollection}\` entry.
+Name template: ${wf.kbOutputTemplate.nameTemplate}
+Description field: ${wf.kbOutputTemplate.descriptionField}
+` + kbContext + `
+
+---
+
+**BEGIN THE WORKFLOW NOW.** Start with Round 01. Create a Plan first.`
+            }
+          }
+        ]
+      };
+    }
+  );
 }
 
 // src/index.ts
 if (!process.env.CONVEX_SITE_URL && !process.env.PRODUCTBRAIN_API_KEY) {
   try {
-    const envPath = resolve2(process.cwd(), ".env.mcp");
-    for (const line of readFileSync2(envPath, "utf-8").split("\n")) {
+    const envPath = resolve3(process.cwd(), ".env.mcp");
+    for (const line of readFileSync3(envPath, "utf-8").split("\n")) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
       const eqIdx = trimmed.indexOf("=");
@@ -2482,7 +4180,7 @@ var workspaceId;
 try {
   workspaceId = await getWorkspaceId();
 } catch (err) {
-  const hint = !process.env.PRODUCTBRAIN_API_KEY && !process.env.CONVEX_SITE_URL ? "\n[MCP] Hint: Set PRODUCTBRAIN_API_KEY in your MCP config env block. Get your key at SynergyOS \u2192 Settings \u2192 API Keys." : "";
+  const hint = !process.env.PRODUCTBRAIN_API_KEY && !process.env.CONVEX_SITE_URL ? "\n[MCP] Hint: Set PRODUCTBRAIN_API_KEY in your MCP config env block, or run `npx productbrain setup`." : "";
   process.stderr.write(`[MCP] Startup failed: ${err.message}${hint}
 `);
   process.exit(1);
@@ -2500,7 +4198,7 @@ var server = new McpServer2(
   {
     capabilities: { logging: {} },
     instructions: [
-      "ProductBrain \u2014 the single source of truth for product knowledge.",
+      "Product Brain \u2014 the single source of truth for product knowledge.",
       "Terminology, standards, and core data all live here \u2014 no need to check external docs.",
       "",
       "Terminology & naming: For 'what is X?' or naming questions, fetch `productbrain://terminology`",
@@ -2533,6 +4231,9 @@ registerLabelTools(server);
 registerHealthTools(server);
 registerVerifyTools(server);
 registerSmartCaptureTools(server);
+registerArchitectureTools(server);
+registerWorkflowTools(server);
+registerGitChainTools(server);
 registerResources(server);
 registerPrompts(server);
 var transport = new StdioServerTransport();