@productbrain/mcp 0.0.1-beta.0

package/dist/index.js

@@ -0,0 +1,2546 @@
+#!/usr/bin/env node
+import "./chunk-DGUM43GV.js";
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/knowledge.ts
+import { z } from "zod";
+
+// src/analytics.ts
+import { userInfo } from "os";
+import { PostHog } from "posthog-node";
+var client = null;
+var distinctId = "anonymous";
+var POSTHOG_HOST = "https://eu.i.posthog.com";
+function log(msg) {
+  if (process.env.MCP_DEBUG === "1") {
+    process.stderr.write(msg);
+  }
+}
+function initAnalytics() {
+  const apiKey = process.env.POSTHOG_MCP_KEY;
+  if (!apiKey) {
+    log("[MCP-ANALYTICS] POSTHOG_MCP_KEY not set \u2014 tracking disabled\n");
+    return;
+  }
+  client = new PostHog(apiKey, {
+    host: POSTHOG_HOST,
+    flushAt: 1,
+    flushInterval: 5e3
+  });
+  distinctId = process.env.MCP_USER_ID || fallbackDistinctId();
+  log(`[MCP-ANALYTICS] Initialized \u2014 host=${POSTHOG_HOST} distinctId=${distinctId}
+`);
+}
+function fallbackDistinctId() {
+  try {
+    return userInfo().username;
+  } catch {
+    return `os-${process.pid}`;
+  }
+}
+function trackSessionStarted(workspaceSlug, workspaceId2, serverVersion) {
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "mcp_session_started",
+    properties: {
+      workspace_slug: workspaceSlug,
+      workspace_id: workspaceId2,
+      server_version: serverVersion,
+      source: "mcp-server",
+      $groups: { workspace: workspaceId2 }
+    }
+  });
+}
+function trackToolCall(fn, status, durationMs, workspaceId2, errorMsg) {
+  const properties = {
+    tool: fn,
+    status,
+    duration_ms: durationMs,
+    workspace_slug: process.env.WORKSPACE_SLUG ?? "unknown",
+    source: "mcp-server",
+    $groups: { workspace: workspaceId2 }
+  };
+  if (errorMsg) properties.error = errorMsg;
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "mcp_tool_called",
+    properties
+  });
+}
+async function shutdownAnalytics() {
+  await client?.shutdown();
+}
+
+// src/client.ts
+var DEFAULT_CLOUD_URL = "https://earnest-sheep-635.convex.site";
+var cachedWorkspaceId = null;
+var cloudMode = false;
+var AUDIT_BUFFER_SIZE = 50;
+var auditBuffer = [];
+function bootstrapCloudMode() {
+  const pbKey = process.env.PRODUCTBRAIN_API_KEY;
+  if (pbKey?.startsWith("pb_sk_")) {
+    const cloudUrl = process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
+    process.env.CONVEX_SITE_URL ??= cloudUrl;
+    process.env.MCP_API_KEY ??= pbKey;
+    cloudMode = true;
+  }
+}
+function getEnv(key) {
+  const value = process.env[key];
+  if (!value) throw new Error(`${key} environment variable is required`);
+  return value;
+}
+function shouldLogAudit(status) {
+  return status === "error" || process.env.MCP_DEBUG === "1";
+}
+function audit(fn, status, durationMs, errorMsg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const workspace = cachedWorkspaceId ?? "unresolved";
+  const entry = { ts, fn, workspace, status, durationMs };
+  if (errorMsg) entry.error = errorMsg;
+  auditBuffer.push(entry);
+  if (auditBuffer.length > AUDIT_BUFFER_SIZE) auditBuffer.shift();
+  trackToolCall(fn, status, durationMs, workspace, errorMsg);
+  if (!shouldLogAudit(status)) return;
+  const base = `[MCP-AUDIT] ${ts} fn=${fn} workspace=${workspace} status=${status} duration=${durationMs}ms`;
+  if (status === "error" && errorMsg) {
+    process.stderr.write(`${base} error=${JSON.stringify(errorMsg)}
+`);
+  } else {
+    process.stderr.write(`${base}
+`);
+  }
+}
+function getAuditLog() {
+  return auditBuffer;
+}
+async function mcpCall(fn, args = {}) {
+  const siteUrl = getEnv("CONVEX_SITE_URL").replace(/\/$/, "");
+  const apiKey = getEnv("MCP_API_KEY");
+  const start = Date.now();
+  let res;
+  try {
+    res = await fetch(`${siteUrl}/api/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ fn, args })
+    });
+  } catch (err) {
+    audit(fn, "error", Date.now() - start, err.message);
+    throw new Error(`MCP call "${fn}" network error: ${err.message}`);
+  }
+  const json = await res.json();
+  if (!res.ok || json.error) {
+    audit(fn, "error", Date.now() - start, json.error);
+    throw new Error(`MCP call "${fn}" failed (${res.status}): ${json.error ?? "unknown error"}`);
+  }
+  audit(fn, "ok", Date.now() - start);
+  return json.data;
+}
+async function getWorkspaceId() {
+  if (cachedWorkspaceId) return cachedWorkspaceId;
+  if (cloudMode) {
+    const workspace2 = await mcpCall(
+      "resolveWorkspace",
+      { slug: "__cloud__" }
+    );
+    if (!workspace2) {
+      throw new Error("Cloud key is valid but no workspace is associated. Run `npx productbrain setup` again.");
+    }
+    cachedWorkspaceId = workspace2._id;
+    return cachedWorkspaceId;
+  }
+  const slug = getEnv("WORKSPACE_SLUG");
+  const workspace = await mcpCall(
+    "resolveWorkspace",
+    { slug }
+  );
+  if (!workspace) {
+    throw new Error(`Workspace with slug "${slug}" not found`);
+  }
+  cachedWorkspaceId = workspace._id;
+  return cachedWorkspaceId;
+}
+async function mcpQuery(fn, args = {}) {
+  const workspaceId2 = await getWorkspaceId();
+  return mcpCall(fn, { ...args, workspaceId: workspaceId2 });
+}
+async function mcpMutation(fn, args = {}) {
+  const workspaceId2 = await getWorkspaceId();
+  return mcpCall(fn, { ...args, workspaceId: workspaceId2 });
+}
+
+// src/tools/knowledge.ts
+function extractPreview(data, maxLen) {
+  if (!data || typeof data !== "object") return "";
+  const raw = data.description ?? data.canonical ?? data.detail ?? "";
+  if (typeof raw !== "string" || !raw) return "";
+  return raw.length > maxLen ? raw.substring(0, maxLen) + "..." : raw;
+}
+function registerKnowledgeTools(server2) {
+  server2.registerTool(
+    "list-collections",
+    {
+      title: "Browse Collections",
+      description: "List every knowledge collection in the workspace \u2014 glossary, business rules, tracking events, standards, etc. Returns each collection's slug, name, description, and field schema. Start here before create-entry so you know which collections exist and what fields they expect.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const collections = await mcpQuery("kb.listCollections");
+      if (collections.length === 0) {
+        return { content: [{ type: "text", text: "No collections found in this workspace." }] };
+      }
+      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.name} (\`${c.slug}\`)
+${c.description || "_No description_"}
+
+**Fields:**
+${fieldList}`;
+      }).join("\n\n---\n\n");
+      return {
+        content: [{ type: "text", text: `# Knowledge Collections (${collections.length})
+
+${formatted}` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "list-entries",
+    {
+      title: "Browse Entries",
+      description: "List entries in a collection, with optional filters for status, tag, or label. Returns entry IDs, names, status, and a data preview. Use list-collections first to discover available collection slugs.",
+      inputSchema: {
+        collection: z.string().optional().describe("Collection slug, e.g. 'glossary', 'tracking-events', 'business-rules'"),
+        status: z.string().optional().describe("Filter: draft | active | verified | deprecated"),
+        tag: z.string().optional().describe("Filter by internal tag, e.g. 'health:ambiguous'"),
+        label: z.string().optional().describe("Filter by label slug \u2014 matches entries across all collections")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ collection, status, tag, label }) => {
+      let entries;
+      if (label) {
+        entries = await mcpQuery("kb.listEntriesByLabel", { labelSlug: label });
+        if (status) entries = entries.filter((e) => e.status === status);
+      } else {
+        entries = await mcpQuery("kb.listEntries", {
+          collectionSlug: collection,
+          status,
+          tag
+        });
+      }
+      if (entries.length === 0) {
+        return { content: [{ type: "text", text: "No entries match the given filters." }] };
+      }
+      const formatted = entries.map((e) => {
+        const id = e.entryId ? `**${e.entryId}:** ` : "";
+        const dataPreview = e.data ? Object.entries(e.data).slice(0, 4).map(([k, v]) => `  ${k}: ${typeof v === "string" ? v.substring(0, 120) : JSON.stringify(v)}`).join("\n") : "";
+        return `- ${id}${e.name} \`${e.status}\`${dataPreview ? `
+${dataPreview}` : ""}`;
+      }).join("\n\n");
+      const scope = collection ? ` in \`${collection}\`` : "";
+      return {
+        content: [{ type: "text", text: `# Entries${scope} (${entries.length})
+
+${formatted}` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get-entry",
+    {
+      title: "Look Up Entry",
+      description: "Retrieve a single knowledge entry by its human-readable ID (e.g. 'T-SUPPLIER', 'BR-001', 'EVT-workspace_created'). Returns the full record: all data fields, labels, relations, and change history. Use kb-search or list-entries first to discover entry IDs.",
+      inputSchema: {
+        entryId: z.string().describe("Entry ID, e.g. 'T-SUPPLIER', 'BR-001', 'EVT-workspace_created'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ entryId }) => {
+      const entry = await mcpQuery("kb.getEntry", { entryId });
+      if (!entry) {
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+      }
+      const lines = [
+        `# ${entry.entryId ? `${entry.entryId}: ` : ""}${entry.name}`,
+        "",
+        `**Status:** ${entry.status}`
+      ];
+      if (entry.data && typeof entry.data === "object") {
+        lines.push("");
+        for (const [key, val] of Object.entries(entry.data)) {
+          const display = typeof val === "string" ? val : JSON.stringify(val);
+          lines.push(`**${key}:** ${display}`);
+        }
+      }
+      if (entry.tags?.length > 0) {
+        lines.push("", `**Tags:** ${entry.tags.join(", ")}`);
+      }
+      if (entry.labels?.length > 0) {
+        lines.push("", `**Labels:** ${entry.labels.map((l) => `\`${l.slug ?? l.name}\``).join(", ")}`);
+      }
+      if (entry.relations?.length > 0) {
+        lines.push("", "## Relations");
+        for (const r of entry.relations) {
+          const arrow = r.direction === "outgoing" ? "\u2192" : "\u2190";
+          const other = r.otherEntryId ? `${r.otherEntryId}: ${r.otherName}` : r.otherName ?? "unknown";
+          lines.push(`- ${arrow} **${r.type}** ${other}`);
+        }
+      }
+      if (entry.history?.length > 0) {
+        lines.push("", "## History (last 10)");
+        for (const h of entry.history.slice(-10)) {
+          const date = new Date(h.timestamp).toISOString().split("T")[0];
+          lines.push(`- ${date}: ${h.event}${h.changedBy ? ` _(${h.changedBy})_` : ""}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  const governedCollections = /* @__PURE__ */ new Set([
+    "glossary",
+    "business-rules",
+    "principles",
+    "standards",
+    "strategy"
+  ]);
+  server2.registerTool(
+    "create-entry",
+    {
+      title: "Create Entry",
+      description: "Create a new knowledge entry. Provide the collection slug, a display name, status, and data matching the collection's field schema. Call list-collections first to see available collections and their field definitions. Governed collections (glossary, business-rules, principles, standards, strategy) require status 'draft' \u2014 to promote to 'active' or 'verified', raise a tension or use update-entry after approval.",
+      inputSchema: {
+        collection: z.string().describe("Collection slug, e.g. 'tracking-events', 'standards', 'glossary'"),
+        entryId: z.string().optional().describe("Human-readable ID, e.g. 'EVT-workspace_created', 'STD-posthog-events'"),
+        name: z.string().describe("Display name"),
+        status: z.string().default("draft").describe("Lifecycle status: draft | active | verified | deprecated"),
+        data: z.record(z.unknown()).describe("Data object \u2014 keys must match the collection's field definitions"),
+        order: z.number().optional().describe("Manual sort order within the collection")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ collection, entryId, name, status, data, order }) => {
+      if (governedCollections.has(collection) && status !== "draft" && status !== "deprecated") {
+        return {
+          content: [{
+            type: "text",
+            text: `# Governance Required
+
+The \`${collection}\` collection is governed. New entries must be created with status \`draft\`.
+
+**How to proceed:**
+1. Create the entry with status \`draft\` (treated as a proposal)
+2. Raise a tension in the \`tensions\` collection to request promotion
+3. After approval, use \`update-entry\` to change status to \`active\` or \`verified\``
+          }]
+        };
+      }
+      try {
+        const id = await mcpMutation("kb.createEntry", {
+          collectionSlug: collection,
+          entryId,
+          name,
+          status,
+          data,
+          order
+        });
+        return {
+          content: [{ type: "text", text: `# Entry Created
+
+**${entryId ?? name}** added to \`${collection}\` as \`${status}\`.
+
+Internal ID: ${id}` }]
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("Duplicate entry") || msg.includes("already exists")) {
+          return {
+            content: [{
+              type: "text",
+              text: `# Cannot Create \u2014 Duplicate Detected
+
+${msg}
+
+**What to do:**
+- Use \`get-entry\` to inspect the existing entry
+- Use \`update-entry\` to modify it
+- If a genuinely new entry is needed, raise a tension to propose it`
+            }]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server2.registerTool(
+    "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).",
+      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")
+      },
+      annotations: { idempotentHint: true, destructiveHint: false }
+    },
+    async ({ entryId, name, status, data, order }) => {
+      try {
+        const id = await mcpMutation("kb.updateEntry", {
+          entryId,
+          name,
+          status,
+          data,
+          order
+        });
+        return {
+          content: [{ type: "text", text: `# Entry Updated
+
+**${entryId}** has been updated.
+
+Internal ID: ${id}` }]
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("SOS-020")) {
+          return {
+            content: [{
+              type: "text",
+              text: `# SOS-020: Tension Status Cannot Be Changed via MCP
+
+Tension status (open, in-progress, closed) must be changed through the defined process, not via MCP.
+
+**What you can do:**
+- 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
+
+Process criteria (TBD): e.g. 3+ users approved, or 7 days without valid concerns.`
+            }]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server2.registerTool(
+    "kb-search",
+    {
+      title: "Search Knowledge Base",
+      description: "Full-text search across all knowledge entries. Returns entry names, collection, status, and a description preview. Scope results to a specific collection (e.g. collection='business-rules') or filter by status (e.g. status='active'). Use this to discover entries before calling get-entry for full details.",
+      inputSchema: {
+        query: z.string().describe("Search text (min 2 characters)"),
+        collection: z.string().optional().describe("Scope to a collection slug, e.g. 'business-rules', 'glossary', 'tracking-events'"),
+        status: z.string().optional().describe("Filter by status: draft | active | verified | deprecated")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async ({ query, collection, status }) => {
+      const scope = collection ? ` in \`${collection}\`` : "";
+      await server2.sendLoggingMessage({ level: "info", data: `Searching${scope} for "${query}"...`, logger: "product-os" });
+      const [results, collections] = await Promise.all([
+        mcpQuery("kb.searchEntries", { query, collectionSlug: collection, status }),
+        mcpQuery("kb.listCollections")
+      ]);
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: `No results for "${query}"${scope}. Try a broader search or check list-collections for available data.` }] };
+      }
+      const collMap = /* @__PURE__ */ new Map();
+      for (const c of collections) {
+        collMap.set(c._id, { name: c.name, slug: c.slug });
+      }
+      const countsBySlug = /* @__PURE__ */ new Map();
+      for (const e of results) {
+        const col = collMap.get(e.collectionId);
+        const slug = col?.slug ?? "unknown";
+        countsBySlug.set(slug, (countsBySlug.get(slug) ?? 0) + 1);
+      }
+      const collSummary = [...countsBySlug.entries()].sort((a, b) => b[1] - a[1]).map(([slug, count]) => `${count} ${slug}`).join(", ");
+      const formatted = results.map((e) => {
+        const id = e.entryId ? `**${e.entryId}:** ` : "";
+        const col = collMap.get(e.collectionId);
+        const colTag = col ? ` [${col.slug}]` : "";
+        const desc = extractPreview(e.data, 150);
+        const preview = desc ? `
+  ${desc}` : "";
+        return `- ${id}${e.name} \`${e.status}\`${colTag}${preview}`;
+      }).join("\n");
+      const header = `# Search Results for "${query}"${scope} (${results.length} match${results.length === 1 ? "" : "es"})
+
+**By collection:** ${collSummary}`;
+      const footer = `_Tip: Use \`collection\` param to scope search. Use get-entry with an entry ID for full details._`;
+      return {
+        content: [{ type: "text", text: `${header}
+
+${formatted}
+
+${footer}` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "get-history",
+    {
+      title: "Entry Change History",
+      description: "Get the audit trail for an entry \u2014 when it was created, updated, status-changed, etc. Returns timestamped events with change details.",
+      inputSchema: {
+        entryId: z.string().describe("Entry ID, e.g. 'T-SUPPLIER', 'BR-001'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ entryId }) => {
+      const history = await mcpQuery("kb.listEntryHistory", { entryId });
+      if (history.length === 0) {
+        return { content: [{ type: "text", text: `No history found for \`${entryId}\`.` }] };
+      }
+      const formatted = history.map((h) => {
+        const date = new Date(h.timestamp).toISOString();
+        const changes = h.changes ? ` \u2014 ${JSON.stringify(h.changes)}` : "";
+        return `- **${date}** ${h.event}${h.changedBy ? ` _(${h.changedBy})_` : ""}${changes}`;
+      }).join("\n");
+      return {
+        content: [{ type: "text", text: `# History for \`${entryId}\` (${history.length} events)
+
+${formatted}` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "relate-entries",
+    {
+      title: "Link Two Entries",
+      description: "Create a typed relation between two entries, building the knowledge graph. Use get-entry to see existing relations before adding new ones.\n\nRecommended relation types (extensible \u2014 any string is accepted):\n- related_to, depends_on, replaces, conflicts_with, references, confused_with\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\nCheck glossary for relation type definitions if unsure which to use.",
+      inputSchema: {
+        from: z.string().describe("Source entry ID, e.g. 'T-SUPPLIER'"),
+        to: z.string().describe("Target entry ID, e.g. 'BR-001'"),
+        type: z.string().describe("Relation type \u2014 use a recommended type or any descriptive string")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ from, to, type }) => {
+      await mcpMutation("kb.createEntryRelation", {
+        fromEntryId: from,
+        toEntryId: to,
+        type
+      });
+      return {
+        content: [{ type: "text", text: `# Relation Created
+
+**${from}** \u2014[${type}]\u2192 **${to}**` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "find-related",
+    {
+      title: "Find Related Entries",
+      description: "Navigate the knowledge graph \u2014 find all entries related to a given entry. Shows incoming references (what points to this entry), outgoing references (what this entry points to), or both. Use after get-entry to explore connections, or to answer 'what depends on X?' or 'what references Y?'",
+      inputSchema: {
+        entryId: z.string().describe("Entry ID, e.g. 'GT-019', 'SOS-006'"),
+        direction: z.enum(["incoming", "outgoing", "both"]).default("both").describe("Filter: 'incoming' = what references this entry, 'outgoing' = what this entry references")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ entryId, direction }) => {
+      const relations = await mcpQuery("kb.listEntryRelations", { entryId });
+      if (relations.length === 0) {
+        return { content: [{ type: "text", text: `No relations found for \`${entryId}\`. Use relate-entries to create connections.` }] };
+      }
+      const sourceEntry = await mcpQuery("kb.getEntry", { entryId });
+      if (!sourceEntry) {
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+      }
+      const sourceInternalId = sourceEntry._id;
+      const MAX_RELATIONS = 25;
+      const truncated = relations.length > MAX_RELATIONS;
+      const capped = relations.slice(0, MAX_RELATIONS);
+      const otherIds = /* @__PURE__ */ new Set();
+      for (const r of capped) {
+        const otherId = r.fromId === sourceInternalId ? r.toId : r.fromId;
+        otherIds.add(otherId);
+      }
+      const otherEntries = /* @__PURE__ */ new Map();
+      for (const id of otherIds) {
+        const entry = await mcpQuery("kb.getEntry", { id });
+        if (entry) {
+          otherEntries.set(entry._id, { entryId: entry.entryId, name: entry.name, collectionId: entry.collectionId });
+        }
+      }
+      const collections = await mcpQuery("kb.listCollections");
+      const collMap = /* @__PURE__ */ new Map();
+      for (const c of collections) collMap.set(c._id, c.slug);
+      const lines = [`# Relations for ${entryId}: ${sourceEntry.name}`, ""];
+      const enriched = capped.map((r) => {
+        const isOutgoing = r.fromId === sourceInternalId;
+        const otherId = isOutgoing ? r.toId : r.fromId;
+        const other = otherEntries.get(otherId);
+        const otherLabel = other?.entryId ? `${other.entryId}: ${other.name}` : other?.name ?? "(deleted)";
+        const colSlug = other ? collMap.get(other.collectionId) ?? "unknown" : "unknown";
+        return { isOutgoing, type: r.type, otherLabel, colSlug };
+      });
+      const outgoing = enriched.filter((r) => r.isOutgoing);
+      const incoming = enriched.filter((r) => !r.isOutgoing);
+      if ((direction === "outgoing" || direction === "both") && outgoing.length > 0) {
+        lines.push(`## Outgoing (${outgoing.length})`);
+        for (const r of outgoing) {
+          lines.push(`- \u2192 **${r.type}** ${r.otherLabel} [${r.colSlug}]`);
+        }
+        lines.push("");
+      }
+      if ((direction === "incoming" || direction === "both") && incoming.length > 0) {
+        lines.push(`## Incoming (${incoming.length})`);
+        for (const r of incoming) {
+          lines.push(`- \u2190 **${r.type}** ${r.otherLabel} [${r.colSlug}]`);
+        }
+        lines.push("");
+      }
+      const shown = direction === "outgoing" ? outgoing : direction === "incoming" ? incoming : enriched;
+      if (shown.length === 0) {
+        lines.push(`No ${direction} relations found for \`${entryId}\`.`);
+      }
+      if (truncated) {
+        lines.push(`_Showing first ${MAX_RELATIONS} of ${relations.length} relations. Use get-entry for the full picture._`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "gather-context",
+    {
+      title: "Gather Full Context",
+      description: "Assemble the full knowledge context around an entry by traversing the knowledge graph. Returns all related entries grouped by collection \u2014 glossary terms, business rules, tensions, decisions, features, etc. Use this when starting work on a feature or investigating an area to get the complete picture in one call.\n\nExample: gather-context entryId='FEAT-001' returns all glossary terms, business rules, and tensions linked to that feature.",
+      inputSchema: {
+        entryId: z.string().describe("Entry ID, e.g. 'FEAT-001', 'GT-019', 'BR-007'"),
+        maxHops: z.number().min(1).max(3).default(2).describe("How many relation hops to traverse (1=direct only, 2=default, 3=wide net)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ entryId, maxHops }) => {
+      const result = await mcpQuery("kb.gatherContext", { entryId, maxHops });
+      if (!result?.root) {
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+      }
+      if (result.related.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `# Context for ${result.root.entryId}: ${result.root.name}
+
+_No relations found._ This entry is not yet connected to the knowledge graph.
+
+Use \`suggest-links\` to discover potential connections, or \`relate-entries\` to link manually.`
+          }]
+        };
+      }
+      const byCollection = /* @__PURE__ */ new Map();
+      for (const entry of result.related) {
+        const key = entry.collectionName;
+        if (!byCollection.has(key)) byCollection.set(key, []);
+        byCollection.get(key).push(entry);
+      }
+      const lines = [
+        `# Context for ${result.root.entryId}: ${result.root.name}`,
+        `_${result.totalRelations} related entries across ${byCollection.size} collections (${result.hopsTraversed} hops traversed)_`,
+        ""
+      ];
+      for (const [collName, entries] of byCollection) {
+        lines.push(`## ${collName} (${entries.length})`);
+        for (const e of entries) {
+          const arrow = e.relationDirection === "outgoing" ? "\u2192" : "\u2190";
+          const hopLabel = e.hop > 1 ? ` (hop ${e.hop})` : "";
+          const id = e.entryId ? `${e.entryId}: ` : "";
+          lines.push(`- ${arrow} **${e.relationType}** ${id}${e.name}${hopLabel}`);
+        }
+        lines.push("");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "suggest-links",
+    {
+      title: "Suggest Links",
+      description: "Discover potential connections for an entry by scanning the knowledge base for related content. Returns ranked suggestions based on text similarity \u2014 review them and use relate-entries to create the ones that make sense.\n\nThis is a discovery tool, not auto-linking. Always review suggestions before linking.",
+      inputSchema: {
+        entryId: z.string().describe("Entry ID to find suggestions for, e.g. 'FEAT-001'"),
+        limit: z.number().min(1).max(20).default(10).describe("Max number of suggestions to return")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ entryId, limit }) => {
+      const entry = await mcpQuery("kb.getEntry", { entryId });
+      if (!entry) {
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+      }
+      const searchTerms = [entry.name];
+      if (entry.data?.description) searchTerms.push(entry.data.description);
+      if (entry.data?.canonical) searchTerms.push(entry.data.canonical);
+      if (entry.data?.rationale) searchTerms.push(entry.data.rationale);
+      if (entry.data?.rule) searchTerms.push(entry.data.rule);
+      const queryText = searchTerms.join(" ").replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3).slice(0, 8).join(" ");
+      if (!queryText) {
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` has too little text content to generate suggestions.` }] };
+      }
+      const results = await mcpQuery("kb.searchEntries", { query: queryText });
+      if (!results || results.length === 0) {
+        return { content: [{ type: "text", text: `No suggestions found for \`${entryId}\`. The knowledge base may need more entries.` }] };
+      }
+      const existingRelations = await mcpQuery("kb.listEntryRelations", { entryId });
+      const relatedIds = new Set(
+        existingRelations.flatMap((r) => [r.fromId, r.toId])
+      );
+      const collections = await mcpQuery("kb.listCollections");
+      const collMap = /* @__PURE__ */ new Map();
+      for (const c of collections) collMap.set(c._id, c.slug);
+      const suggestions = results.filter((r) => r._id !== entry._id && !relatedIds.has(r._id)).slice(0, limit).map((r) => ({
+        entryId: r.entryId,
+        name: r.name,
+        collection: collMap.get(r.collectionId) ?? "unknown",
+        preview: extractPreview(r.data, 80)
+      }));
+      if (suggestions.length === 0) {
+        return { content: [{ type: "text", text: `No new link suggestions for \`${entryId}\` \u2014 it may already be well-connected, or no similar entries exist.` }] };
+      }
+      const lines = [
+        `# Link Suggestions for ${entryId}: ${entry.name}`,
+        `_${suggestions.length} potential connections found. Review and use \`relate-entries\` to create the ones that make sense._`,
+        ""
+      ];
+      for (let i = 0; i < suggestions.length; i++) {
+        const s = suggestions[i];
+        const preview = s.preview ? ` \u2014 ${s.preview}` : "";
+        lines.push(`${i + 1}. **${s.entryId ?? "(no ID)"}**: ${s.name} [${s.collection}]${preview}`);
+      }
+      lines.push("");
+      lines.push("**To link:** `relate-entries from='FEAT-001' to='GT-019' type='defines_term_for'`");
+      lines.push("");
+      lines.push("_Recommended relation types: governs, defines_term_for, belongs_to, informs, surfaces_tension_in, related_to, depends_on_");
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "quick-capture",
+    {
+      title: "Quick Capture",
+      description: "Quickly capture a knowledge entry with just a name and description \u2014 no need to look up the full field schema first. Always creates as 'draft' status with sensible defaults for remaining fields. Use update-entry later to fill in details. Embodies 'Capture Now, Curate Later' (PRI-81cbdq).",
+      inputSchema: {
+        collection: z.string().describe("Collection slug, e.g. 'business-rules', 'glossary', 'tensions', 'decisions'"),
+        name: z.string().describe("Display name for the entry"),
+        description: z.string().describe("Short description \u2014 the essential context to capture now"),
+        entryId: z.string().optional().describe("Optional human-readable ID (e.g. 'SOS-020', 'GT-031')")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ collection, name, description, entryId }) => {
+      const col = await mcpQuery("kb.getCollection", { slug: collection });
+      if (!col) {
+        return { content: [{ type: "text", text: `Collection \`${collection}\` not found. Use list-collections to see available collections.` }] };
+      }
+      const data = {};
+      const emptyFields = [];
+      for (const field of col.fields ?? []) {
+        const key = field.key;
+        if (key === "description" || key === "canonical" || key === "detail") {
+          data[key] = description;
+        } else if (field.type === "array" || field.type === "multi-select") {
+          data[key] = [];
+          emptyFields.push(key);
+        } else if (field.type === "select") {
+          data[key] = field.options?.[0] ?? "";
+          emptyFields.push(key);
+        } else {
+          data[key] = "";
+          emptyFields.push(key);
+        }
+      }
+      if (!data.description && !data.canonical && !data.detail) {
+        data.description = description;
+      }
+      try {
+        const id = await mcpMutation("kb.createEntry", {
+          collectionSlug: collection,
+          entryId,
+          name,
+          status: "draft",
+          data
+        });
+        const emptyNote = emptyFields.length > 0 ? `
+
+**Fields to fill later** (via \`update-entry\`):
+${emptyFields.map((f) => `- \`${f}\``).join("\n")}` : "";
+        return {
+          content: [{
+            type: "text",
+            text: `# Quick Capture \u2014 Done
+
+**${entryId ?? name}** added to \`${collection}\` as \`draft\`.
+
+Internal ID: ${id}${emptyNote}
+
+_Use \`update-entry\` to fill in details when ready. Use \`get-entry\` to review._`
+          }]
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("Duplicate") || msg.includes("already exists")) {
+          return {
+            content: [{
+              type: "text",
+              text: `# Cannot Capture \u2014 Duplicate Detected
+
+${msg}
+
+Use \`get-entry\` to inspect the existing entry, or \`update-entry\` to modify it.`
+            }]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server2.registerTool(
+    "load-context-for-task",
+    {
+      title: "Load Context for Task",
+      description: "Auto-load relevant domain knowledge for a task in a single call. Pass a natural-language task description; the tool searches the KB, traverses the knowledge graph, and returns a ranked set of entries (business rules, glossary terms, decisions, features, etc.) grouped by collection with a confidence score.\n\nUse this at the start of a conversation to ground the agent in domain context before writing code or making recommendations.\n\nConfidence levels:\n- high: 3+ direct KB matches \u2014 strong domain coverage\n- medium: 1-2 direct matches \u2014 partial coverage, may want to drill deeper\n- low: no direct matches but related entries found via graph traversal\n- none: no relevant entries found \u2014 KB may not cover this area yet",
+      inputSchema: {
+        taskDescription: z.string().describe("Natural-language description of the task or user message"),
+        maxResults: z.number().min(1).max(25).default(10).optional().describe("Max entries to return (default 10)"),
+        maxHops: z.number().min(1).max(3).default(2).optional().describe("Graph traversal depth from each search hit (default 2)")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async ({ taskDescription, maxResults, maxHops }) => {
+      await server2.sendLoggingMessage({
+        level: "info",
+        data: `Loading context for task: "${taskDescription.substring(0, 80)}..."`,
+        logger: "product-os"
+      });
+      const result = await mcpQuery("kb.loadContextForTask", {
+        taskDescription,
+        maxResults: maxResults ?? 10,
+        maxHops: maxHops ?? 2
+      });
+      if (result.confidence === "none" || result.entries.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `# Context Loaded
+
+**Confidence:** None
+
+No KB context found for this task. The knowledge base may not cover this area yet.
+
+_Consider capturing domain knowledge discovered during this task via \`smart-capture\`._`
+          }]
+        };
+      }
+      const byCollection = /* @__PURE__ */ new Map();
+      for (const entry of result.entries) {
+        const key = entry.collectionName;
+        if (!byCollection.has(key)) byCollection.set(key, []);
+        byCollection.get(key).push(entry);
+      }
+      const lines = [
+        `# Context Loaded`,
+        `**Confidence:** ${result.confidence.charAt(0).toUpperCase() + result.confidence.slice(1)}`,
+        `**Matched:** ${result.entries.length} entries across ${byCollection.size} collection${byCollection.size === 1 ? "" : "s"}`,
+        ""
+      ];
+      for (const [collName, entries] of byCollection) {
+        lines.push(`### ${collName} (${entries.length})`);
+        for (const e of entries) {
+          const id = e.entryId ? `**${e.entryId}:** ` : "";
+          const hopLabel = e.hop > 0 ? ` _(hop ${e.hop}${e.relationType ? `, ${e.relationType}` : ""})_` : "";
+          const preview = e.descriptionPreview ? `
+  ${e.descriptionPreview}` : "";
+          const codePaths = e.codePaths.length > 0 ? `
+  Code: ${e.codePaths.join(", ")}` : "";
+          lines.push(`- ${id}${e.name}${hopLabel}${preview}${codePaths}`);
+        }
+        lines.push("");
+      }
+      lines.push(`_Use \`get-entry\` for full details on any entry._`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server2.registerTool(
+    "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.",
+      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.")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ domain, context }) => {
+      const entries = await mcpQuery("kb.listEntries", { collectionSlug: "business-rules" });
+      const domainLower = domain.toLowerCase();
+      const rules = entries.filter((e) => {
+        const ruleDomain = e.data?.domain ?? "";
+        return ruleDomain.toLowerCase() === domainLower || ruleDomain.toLowerCase().includes(domainLower);
+      });
+      if (rules.length === 0) {
+        const allDomains = [...new Set(entries.map((e) => e.data?.domain).filter(Boolean))];
+        return {
+          content: [{
+            type: "text",
+            text: `# No Rules Found for "${domain}"
+
+Available domains:
+${allDomains.map((d) => `- ${d}`).join("\n")}
+
+_Try one of the domains above, or use kb-search to find rules by keyword._`
+          }]
+        };
+      }
+      const header = context ? `# Business Rules: ${domain}
+
+**Review context:** ${context}
+
+For each rule, assess: compliant, at risk, violation, or not applicable.
+` : `# Business Rules: ${domain}
+`;
+      const formatted = rules.map((r) => {
+        const id = r.entryId ? `**${r.entryId}:** ` : "";
+        const severity = r.data?.severity ? ` | Severity: ${r.data.severity}` : "";
+        const desc = r.data?.description ?? "";
+        const impact = r.data?.dataImpact ? `
+  Data impact: ${r.data.dataImpact}` : "";
+        const related = (r.data?.relatedRules ?? []).length > 0 ? `
+  Related: ${r.data.relatedRules.join(", ")}` : "";
+        return `### ${id}${r.name} \`${r.status}\`${severity}
+
+${desc}${impact}${related}`;
+      }).join("\n\n---\n\n");
+      const footer = `
+_${rules.length} rule${rules.length === 1 ? "" : "s"} in this domain. Use \`get-entry\` for full details. Use the \`draft-rule-from-context\` prompt to propose new rules._`;
+      return {
+        content: [{ type: "text", text: `${header}
+${formatted}
+${footer}` }]
+      };
+    }
+  );
+}
+
+// src/tools/labels.ts
+import { z as z2 } from "zod";
+function registerLabelTools(server2) {
+  server2.registerTool(
+    "list-labels",
+    {
+      title: "Browse Labels",
+      description: "List all workspace labels with their groups and hierarchy. Labels can be applied to any entry across any collection for cross-domain filtering. Similar to labels in Linear or GitHub.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const labels = await mcpQuery("kb.listLabels");
+      if (labels.length === 0) {
+        return { content: [{ type: "text", text: "No labels defined in this workspace yet." }] };
+      }
+      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 = ["# Workspace Labels"];
+      for (const group of groups) {
+        lines.push(`
+## ${group.name}`);
+        if (group.description) lines.push(`_${group.description}_`);
+        for (const child of children(group._id)) {
+          const color = child.color ? ` ${child.color}` : "";
+          lines.push(`  - \`${child.slug}\` ${child.name}${color}`);
+        }
+      }
+      if (ungrouped.length > 0) {
+        lines.push("\n## Ungrouped");
+        for (const label of ungrouped) {
+          const color = label.color ? ` ${label.color}` : "";
+          lines.push(`- \`${label.slug}\` ${label.name}${color}${label.description ? ` \u2014 _${label.description}_` : ""}`);
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server2.registerTool(
+    "manage-labels",
+    {
+      title: "Manage Labels",
+      description: "Create, update, or delete a workspace label. Labels support hierarchy (groups with children). Use list-labels first to see what exists.",
+      inputSchema: {
+        action: z2.enum(["create", "update", "delete"]).describe("What to do"),
+        slug: z2.string().describe("Label slug (machine name), e.g. 'p1-critical', 'needs-review'"),
+        name: z2.string().optional().describe("Display name (required for create)"),
+        color: z2.string().optional().describe("Hex color, e.g. '#ef4444'"),
+        description: z2.string().optional().describe("What this label means"),
+        parentSlug: z2.string().optional().describe("Parent group slug for label hierarchy"),
+        isGroup: z2.boolean().optional().describe("True if this is a group container, not a taggable label"),
+        order: z2.number().optional().describe("Sort order within its group")
+      }
+    },
+    async ({ action, slug, name, color, description, parentSlug, isGroup, order }) => {
+      if (action === "create") {
+        if (!name) {
+          return { content: [{ type: "text", text: "Cannot create a label without a name." }] };
+        }
+        let parentId;
+        if (parentSlug) {
+          const labels = await mcpQuery("kb.listLabels");
+          const parent = labels.find((l) => l.slug === parentSlug);
+          if (!parent) {
+            return { content: [{ type: "text", text: `Parent label \`${parentSlug}\` not found. Use list-labels to see available groups.` }] };
+          }
+          parentId = parent._id;
+        }
+        await mcpMutation("kb.createLabel", { slug, name, color, description, parentId, isGroup, order });
+        return { content: [{ type: "text", text: `# Label Created
+
+**${name}** (\`${slug}\`)` }] };
+      }
+      if (action === "update") {
+        await mcpMutation("kb.updateLabel", { slug, name, color, description, isGroup, order });
+        return { content: [{ type: "text", text: `# Label Updated
+
+\`${slug}\` has been updated.` }] };
+      }
+      if (action === "delete") {
+        await mcpMutation("kb.deleteLabel", { slug });
+        return { content: [{ type: "text", text: `# Label Deleted
+
+\`${slug}\` removed from all entries and deleted.` }] };
+      }
+      return { content: [{ type: "text", text: "Unknown action." }] };
+    }
+  );
+  server2.registerTool(
+    "label-entry",
+    {
+      title: "Tag Entry with Label",
+      description: "Apply or remove a label from a knowledge entry. Labels work across all collections for cross-domain filtering. Use list-labels to see available label slugs.",
+      inputSchema: {
+        action: z2.enum(["apply", "remove"]).describe("Apply or remove the label"),
+        entryId: z2.string().describe("Entry ID, e.g. 'T-SUPPLIER', 'EVT-workspace_created'"),
+        label: z2.string().describe("Label slug to apply/remove")
+      }
+    },
+    async ({ action, entryId, label }) => {
+      if (action === "apply") {
+        await mcpMutation("kb.applyLabel", { entryId, labelSlug: label });
+        return { content: [{ type: "text", text: `Label \`${label}\` applied to **${entryId}**.` }] };
+      }
+      await mcpMutation("kb.removeLabel", { entryId, labelSlug: label });
+      return { content: [{ type: "text", text: `Label \`${label}\` removed from **${entryId}**.` }] };
+    }
+  );
+}
+
+// src/tools/health.ts
+import { z as z3 } from "zod";
+var CALL_CATEGORIES = {
+  "kb.getEntry": "read",
+  "kb.listEntries": "read",
+  "kb.listEntryHistory": "read",
+  "kb.listEntryRelations": "read",
+  "kb.listEntriesByLabel": "read",
+  "kb.searchEntries": "search",
+  "kb.createEntry": "write",
+  "kb.updateEntry": "write",
+  "kb.createEntryRelation": "write",
+  "kb.applyLabel": "label",
+  "kb.removeLabel": "label",
+  "kb.createLabel": "label",
+  "kb.updateLabel": "label",
+  "kb.deleteLabel": "label",
+  "kb.listCollections": "meta",
+  "kb.getCollection": "meta",
+  "kb.listLabels": "meta",
+  "resolveWorkspace": "meta"
+};
+function categorize(fn) {
+  return CALL_CATEGORIES[fn] ?? "meta";
+}
+function formatDuration(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  const mins = Math.floor(ms / 6e4);
+  const secs = Math.round(ms % 6e4 / 1e3);
+  return `${mins}m ${secs}s`;
+}
+function buildSessionSummary(log2) {
+  if (log2.length === 0) return "";
+  const byCategory = /* @__PURE__ */ new Map();
+  let errorCount = 0;
+  let writeCreates = 0;
+  let writeUpdates = 0;
+  for (const entry of log2) {
+    const cat = categorize(entry.fn);
+    if (!byCategory.has(cat)) byCategory.set(cat, /* @__PURE__ */ new Map());
+    const fnCounts = byCategory.get(cat);
+    fnCounts.set(entry.fn, (fnCounts.get(entry.fn) ?? 0) + 1);
+    if (entry.status === "error") errorCount++;
+    if (entry.fn === "kb.createEntry" && entry.status === "ok") writeCreates++;
+    if (entry.fn === "kb.updateEntry" && entry.status === "ok") writeUpdates++;
+  }
+  const firstTs = new Date(log2[0].ts).getTime();
+  const lastTs = new Date(log2[log2.length - 1].ts).getTime();
+  const duration = formatDuration(lastTs - firstTs);
+  const lines = [`# Session Summary (${duration})
+`];
+  const categoryLabels = [
+    ["read", "Reads"],
+    ["search", "Searches"],
+    ["write", "Writes"],
+    ["label", "Labels"],
+    ["meta", "Meta"]
+  ];
+  for (const [cat, label] of categoryLabels) {
+    const fnCounts = byCategory.get(cat);
+    if (!fnCounts || fnCounts.size === 0) continue;
+    const total = [...fnCounts.values()].reduce((a, b) => a + b, 0);
+    const detail = [...fnCounts.entries()].sort((a, b) => b[1] - a[1]).map(([fn, count]) => `${fn.replace("kb.", "")} x${count}`).join(", ");
+    lines.push(`- **${label}:** ${total} call${total === 1 ? "" : "s"} (${detail})`);
+  }
+  lines.push(`- **Errors:** ${errorCount}`);
+  if (writeCreates > 0 || writeUpdates > 0) {
+    lines.push("");
+    lines.push("## Knowledge Contribution");
+    if (writeCreates > 0) lines.push(`- ${writeCreates} entr${writeCreates === 1 ? "y" : "ies"} created`);
+    if (writeUpdates > 0) lines.push(`- ${writeUpdates} entr${writeUpdates === 1 ? "y" : "ies"} updated`);
+  }
+  return lines.join("\n");
+}
+function registerHealthTools(server2) {
+  server2.registerTool(
+    "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.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const start = Date.now();
+      const errors = [];
+      let workspaceId2;
+      try {
+        workspaceId2 = await getWorkspaceId();
+      } catch (e) {
+        errors.push(`Workspace resolution failed: ${e.message}`);
+      }
+      let collections = [];
+      try {
+        collections = await mcpQuery("kb.listCollections");
+      } catch (e) {
+        errors.push(`Collection fetch failed: ${e.message}`);
+      }
+      let totalEntries = 0;
+      if (collections.length > 0) {
+        try {
+          const entries = await mcpQuery("kb.listEntries", {});
+          totalEntries = entries.length;
+        } catch (e) {
+          errors.push(`Entry count failed: ${e.message}`);
+        }
+      }
+      const durationMs = Date.now() - start;
+      const healthy = errors.length === 0;
+      const lines = [
+        `# ${healthy ? "Healthy" : "Degraded"}`,
+        "",
+        `**Workspace:** ${workspaceId2 ?? "unresolved"}`,
+        `**Collections:** ${collections.length}`,
+        `**Entries:** ${totalEntries}`,
+        `**Latency:** ${durationMs}ms`
+      ];
+      if (errors.length > 0) {
+        lines.push("", "## Errors");
+        for (const err of errors) {
+          lines.push(`- ${err}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "mcp-audit",
+    {
+      title: "Session Audit Log",
+      description: "Show a session summary (reads, writes, searches, contributions) and the last N backend calls. Useful for debugging, tracing tool behavior, and seeing what you contributed to the knowledge base.",
+      inputSchema: {
+        limit: z3.number().min(1).max(50).default(20).describe("How many recent calls to show (max 50)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ limit }) => {
+      const log2 = getAuditLog();
+      const recent = log2.slice(-limit);
+      if (recent.length === 0) {
+        return { content: [{ type: "text", text: "No calls recorded yet this session." }] };
+      }
+      const summary = buildSessionSummary(log2);
+      const logLines = [`# Audit Log (last ${recent.length} of ${log2.length} total)
+`];
+      for (const entry of recent) {
+        const icon = entry.status === "ok" ? "\u2713" : "\u2717";
+        const errPart = entry.error ? ` \u2014 ${entry.error}` : "";
+        logLines.push(`${icon} \`${entry.fn}\` ${entry.durationMs}ms ${entry.status}${errPart}`);
+      }
+      return {
+        content: [{ type: "text", text: `${summary}
+
+---
+
+${logLines.join("\n")}` }]
+      };
+    }
+  );
+}
+
+// src/tools/verify.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { z as z4 } from "zod";
+function resolveProjectRoot() {
+  const candidates = [
+    process.env.WORKSPACE_PATH,
+    process.cwd(),
+    resolve(process.cwd(), "..")
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    const resolved = resolve(dir);
+    if (existsSync(resolve(resolved, "convex/schema.ts"))) return resolved;
+  }
+  return null;
+}
+function parseConvexSchema(schemaPath) {
+  const content = readFileSync(schemaPath, "utf-8");
+  const tables = /* @__PURE__ */ new Map();
+  let currentTable = null;
+  for (const line of content.split("\n")) {
+    const tableMatch = line.match(/^\t(\w+):\s*defineTable\(/);
+    if (tableMatch) {
+      currentTable = tableMatch[1];
+      tables.set(currentTable, /* @__PURE__ */ new Set());
+      continue;
+    }
+    if (currentTable && /^\t[}\)]/.test(line) && !/^\t\t/.test(line)) {
+      currentTable = null;
+      continue;
+    }
+    if (currentTable) {
+      const fieldMatch = line.match(/^\t\t(\w+):\s*v\./);
+      if (fieldMatch) tables.get(currentTable).add(fieldMatch[1]);
+    }
+  }
+  return tables;
+}
+function cleanFieldRef(field) {
+  return field.replace(/\s*\(.*\)\s*$/, "").replace(/\s*=\s*.*$/, "").trim();
+}
+function splitMultiRefs(field) {
+  if (field.includes(" + ")) return field.split(/\s*\+\s*/);
+  return [field];
+}
+var FILE_EXT_RE = /\.(ts|js|svelte|json|css|md|jsx|tsx|mjs|cjs)(?:\s|$)/i;
+function classifyRef(cleaned) {
+  if (cleaned.includes("/") || FILE_EXT_RE.test(cleaned) || /^\.\w+/.test(cleaned)) {
+    return "file";
+  }
+  if (/^\w+\.\w+$/.test(cleaned)) return "schema";
+  if (/^\w+\s+table$/i.test(cleaned)) return "schema";
+  return "conceptual";
+}
+function checkFileRef(ref, root) {
+  const filePart = ref.split(/\s+/)[0];
+  const fullPath = resolve(root, filePart);
+  if (existsSync(fullPath)) return { result: "verified", reason: "exists" };
+  return { result: "drifted", reason: `not found: ${filePart}` };
+}
+function checkSchemaRef(ref, schema) {
+  const tableOnlyMatch = ref.match(/^(\w+)\s+table$/i);
+  if (tableOnlyMatch) {
+    const table = tableOnlyMatch[1];
+    if (schema.has(table)) return { result: "verified", reason: `table "${table}" exists` };
+    return { result: "drifted", reason: `table "${table}" not found in schema` };
+  }
+  const dotIdx = ref.indexOf(".");
+  if (dotIdx > 0) {
+    const table = ref.slice(0, dotIdx);
+    const field = ref.slice(dotIdx + 1);
+    if (!schema.has(table)) return { result: "drifted", reason: `table "${table}" not found in schema` };
+    if (!schema.get(table).has(field)) return { result: "drifted", reason: `field "${field}" not found in table "${table}"` };
+    return { result: "verified", reason: `${table}.${field} exists` };
+  }
+  return { result: "unverifiable", reason: "could not parse schema reference" };
+}
+function formatTrustReport(collection, entryCount, mappings, refs, fixes, mode, schemaTableCount, projectRoot) {
+  const verified = mappings.filter((c) => c.result === "verified").length;
+  const drifted = mappings.filter((c) => c.result === "drifted").length;
+  const unverifiable = mappings.filter((c) => c.result === "unverifiable").length;
+  const refsValid = refs.filter((c) => c.found).length;
+  const refsBroken = refs.filter((c) => !c.found).length;
+  const totalChecks = mappings.length + refs.length;
+  const totalPassed = verified + refsValid;
+  const trustScore = totalChecks > 0 ? Math.round(totalPassed / totalChecks * 100) : 100;
+  const lines = [
+    `# Trust Report: ${collection} (${entryCount} entries scanned)`,
+    ""
+  ];
+  if (mappings.length > 0) {
+    lines.push(
+      "## Code Mapping Verification",
+      `- ${mappings.length} mappings checked`,
+      `- ${verified} verified (${Math.round(verified / mappings.length * 100)}%)`,
+      `- ${drifted} drifted (file/schema not found)`,
+      `- ${unverifiable} unverifiable (conceptual \u2014 skipped)`,
+      ""
+    );
+  }
+  if (drifted > 0) {
+    lines.push("### Drifted Mappings");
+    for (const mc of mappings.filter((c) => c.result === "drifted")) {
+      lines.push(`- **${mc.entryId}** (${mc.entryName}): \`${mc.field}\` \u2014 ${mc.reason}`);
+    }
+    lines.push("");
+  }
+  if (unverifiable > 0) {
+    lines.push("### Unverifiable (Conceptual)");
+    for (const mc of mappings.filter((c) => c.result === "unverifiable")) {
+      lines.push(`- **${mc.entryId}** (${mc.entryName}): \`${mc.field}\``);
+    }
+    lines.push("");
+  }
+  if (refs.length > 0) {
+    lines.push(
+      "## Cross-Reference Verification",
+      `- ${refs.length} references checked`,
+      `- ${refsValid} valid (${refs.length > 0 ? Math.round(refsValid / refs.length * 100) : 0}%)`,
+      `- ${refsBroken} broken`,
+      ""
+    );
+  }
+  if (refsBroken > 0) {
+    lines.push("### Broken References");
+    for (const rc of refs.filter((c) => !c.found)) {
+      lines.push(`- **${rc.entryId}** (${rc.entryName}): relatedRules \`${rc.refValue}\` \u2014 entry not found`);
+    }
+    lines.push("");
+  }
+  lines.push(`## Trust Score: ${trustScore}% (${totalPassed} of ${totalChecks} checks passed)`);
+  if (mode === "fix" && fixes.length > 0) {
+    lines.push(
+      "",
+      "## Applied Fixes",
+      `Updated codeMapping status from \`aligned\` \u2192 \`drifted\` on ${fixes.length} entr${fixes.length === 1 ? "y" : "ies"}:`
+    );
+    for (const eid of fixes) lines.push(`- ${eid}`);
+  } else if (mode === "report" && drifted > 0) {
+    const fixable = mappings.filter((c) => c.result === "drifted" && c.currentStatus === "aligned").length;
+    if (fixable > 0) {
+      lines.push("", `_${fixable} mapping(s) marked "aligned" but actually drifted. Run with mode="fix" to update._`);
+    }
+  }
+  lines.push("", "---", `_Schema: ${schemaTableCount} tables parsed from convex/schema.ts. Project root: ${projectRoot}_`);
+  return lines.join("\n");
+}
+function registerVerifyTools(server2) {
+  server2.registerTool(
+    "verify",
+    {
+      title: "Verify Knowledge Base",
+      description: "Verify knowledge entries against the actual codebase. Checks glossary code mappings (do referenced files and schema fields still exist?) and validates cross-references (do relatedRules point to real entries?). Produces a trust report with a trust score. Use mode='fix' to auto-update drifted codeMapping statuses.",
+      inputSchema: {
+        collection: z4.string().default("glossary").describe("Collection slug to verify (default: glossary)"),
+        mode: z4.enum(["report", "fix"]).default("report").describe("'report' = read-only trust report. 'fix' = also update drifted codeMapping statuses.")
+      },
+      annotations: { readOnlyHint: false }
+    },
+    async ({ collection, mode }) => {
+      const projectRoot = resolveProjectRoot();
+      if (!projectRoot) {
+        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."
+          }]
+        };
+      }
+      const schema = parseConvexSchema(resolve(projectRoot, "convex/schema.ts"));
+      await server2.sendLoggingMessage({
+        level: "info",
+        data: `Verifying "${collection}" against ${schema.size} schema tables at ${projectRoot}`,
+        logger: "product-os"
+      });
+      const scopedEntries = await mcpQuery("kb.listEntries", { collectionSlug: collection });
+      if (scopedEntries.length === 0) {
+        return {
+          content: [{ type: "text", text: `No entries found in \`${collection}\`. Nothing to verify.` }]
+        };
+      }
+      let allEntryIds;
+      try {
+        const allEntries = await mcpQuery("kb.listEntries", {});
+        allEntryIds = new Set(allEntries.map((e) => e.entryId).filter(Boolean));
+      } catch {
+        allEntryIds = new Set(scopedEntries.map((e) => e.entryId).filter(Boolean));
+      }
+      const mappingChecks = [];
+      const refChecks = [];
+      for (const entry of scopedEntries) {
+        const eid = entry.entryId ?? entry.name;
+        const ename = entry.name;
+        const codeMappings = entry.data?.codeMapping ?? [];
+        for (const cm of codeMappings) {
+          const rawField = cm.field ?? "";
+          for (const rawRef of splitMultiRefs(rawField)) {
+            const cleaned = cleanFieldRef(rawRef);
+            if (!cleaned) continue;
+            const kind = classifyRef(cleaned);
+            let result;
+            let reason;
+            if (kind === "file") {
+              ({ result, reason } = checkFileRef(cleaned, projectRoot));
+            } else if (kind === "schema") {
+              ({ result, reason } = checkSchemaRef(cleaned, schema));
+            } else {
+              result = "unverifiable";
+              reason = "conceptual reference";
+            }
+            mappingChecks.push({
+              entryId: eid,
+              entryName: ename,
+              field: rawRef.trim(),
+              kind,
+              result,
+              reason,
+              currentStatus: cm.status ?? "unknown"
+            });
+          }
+        }
+        const MAX_CROSS_REFS = 50;
+        const relatedRules = entry.data?.relatedRules ?? [];
+        for (const ruleId of relatedRules) {
+          if (refChecks.length >= MAX_CROSS_REFS) break;
+          refChecks.push({
+            entryId: eid,
+            entryName: ename,
+            refValue: ruleId,
+            found: allEntryIds.has(ruleId)
+          });
+        }
+      }
+      const fixes = [];
+      if (mode === "fix") {
+        const driftedByEntry = /* @__PURE__ */ new Map();
+        for (const mc of mappingChecks) {
+          if (mc.result === "drifted" && mc.currentStatus === "aligned") {
+            if (!driftedByEntry.has(mc.entryId)) driftedByEntry.set(mc.entryId, /* @__PURE__ */ new Set());
+            driftedByEntry.get(mc.entryId).add(mc.field);
+          }
+        }
+        for (const [eid, driftedFields] of driftedByEntry) {
+          const entry = scopedEntries.find((e) => (e.entryId ?? e.name) === eid);
+          if (!entry?.entryId) continue;
+          const updated = (entry.data?.codeMapping ?? []).map(
+            (cm) => cm.status === "aligned" && driftedFields.has(cm.field) ? { ...cm, status: "drifted" } : cm
+          );
+          await mcpMutation("kb.updateEntry", {
+            entryId: entry.entryId,
+            data: { codeMapping: updated }
+          });
+          fixes.push(entry.entryId);
+        }
+      }
+      const report = formatTrustReport(
+        collection,
+        scopedEntries.length,
+        mappingChecks,
+        refChecks,
+        fixes,
+        mode,
+        schema.size,
+        projectRoot
+      );
+      return { content: [{ type: "text", text: report }] };
+    }
+  );
+}
+
+// src/tools/smart-capture.ts
+import { z as z5 } from "zod";
+var AREA_KEYWORDS = {
+  "Architecture": ["convex", "schema", "database", "migration", "api", "backend", "infrastructure", "scaling", "performance"],
+  "Knowledge Base": ["knowledge", "glossary", "entry", "collection", "terminology", "drift", "graph"],
+  "AI & MCP Integration": ["mcp", "ai", "cursor", "agent", "tool", "llm", "prompt", "context"],
+  "Developer Experience": ["dx", "developer", "ide", "workflow", "friction", "ceremony"],
+  "Governance & Decision-Making": ["governance", "decision", "rule", "policy", "compliance", "approval"],
+  "Analytics & Tracking": ["analytics", "posthog", "tracking", "event", "metric", "funnel"],
+  "Security": ["security", "auth", "api key", "permission", "access", "token"]
+};
+function inferArea(text) {
+  const lower = text.toLowerCase();
+  let bestArea = "";
+  let bestScore = 0;
+  for (const [area, keywords] of Object.entries(AREA_KEYWORDS)) {
+    const score = keywords.filter((kw) => lower.includes(kw)).length;
+    if (score > bestScore) {
+      bestScore = score;
+      bestArea = area;
+    }
+  }
+  return bestArea;
+}
+function inferDomain(text) {
+  return inferArea(text) || "";
+}
+var COMMON_CHECKS = {
+  clearName: {
+    id: "clear-name",
+    label: "Clear, specific name (not vague)",
+    check: (ctx) => ctx.name.length > 10 && !["new tension", "new entry", "untitled", "test"].includes(ctx.name.toLowerCase()),
+    suggestion: () => "Rename to something specific \u2014 describe the actual problem or concept."
+  },
+  hasDescription: {
+    id: "has-description",
+    label: "Description provided (>50 chars)",
+    check: (ctx) => ctx.description.length > 50,
+    suggestion: () => "Add a fuller description explaining context and impact."
+  },
+  hasRelations: {
+    id: "has-relations",
+    label: "At least 1 relation created",
+    check: (ctx) => ctx.linksCreated.length >= 1,
+    suggestion: () => "Use `suggest-links` and `relate-entries` to connect this entry to related knowledge."
+  },
+  diverseRelations: {
+    id: "diverse-relations",
+    label: "Relations span multiple collections",
+    check: (ctx) => {
+      const colls = new Set(ctx.linksCreated.map((l) => l.targetCollection));
+      return colls.size >= 2;
+    },
+    suggestion: () => "Try linking to entries in different collections (glossary, business-rules, strategy)."
+  }
+};
+var PROFILES = /* @__PURE__ */ new Map([
+  ["tensions", {
+    idPrefix: "TEN",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [
+      { key: "priority", value: "medium" },
+      { key: "date", value: "today" },
+      { key: "raised", value: "infer" },
+      { key: "severity", value: "infer" }
+    ],
+    recommendedRelationTypes: ["surfaces_tension_in", "references", "belongs_to", "related_to"],
+    inferField: (ctx) => {
+      const fields = {};
+      const text = `${ctx.name} ${ctx.description}`;
+      const area = inferArea(text);
+      if (area) fields.raised = area;
+      if (text.toLowerCase().includes("critical") || text.toLowerCase().includes("blocker")) {
+        fields.severity = "critical";
+      } else if (text.toLowerCase().includes("bottleneck") || text.toLowerCase().includes("scaling") || text.toLowerCase().includes("breaking")) {
+        fields.severity = "high";
+      } else {
+        fields.severity = "medium";
+      }
+      if (area) fields.affectedArea = area;
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      {
+        id: "has-severity",
+        label: "Severity specified",
+        check: (ctx) => !!ctx.data.severity && ctx.data.severity !== "",
+        suggestion: (ctx) => {
+          const text = `${ctx.name} ${ctx.description}`.toLowerCase();
+          const inferred = text.includes("critical") ? "critical" : text.includes("bottleneck") ? "high" : "medium";
+          return `Set severity \u2014 suggest: ${inferred} (based on description keywords).`;
+        }
+      },
+      {
+        id: "has-affected-area",
+        label: "Affected area identified",
+        check: (ctx) => !!ctx.data.affectedArea && ctx.data.affectedArea !== "",
+        suggestion: (ctx) => {
+          const area = inferArea(`${ctx.name} ${ctx.description}`);
+          return area ? `Set affectedArea \u2014 suggest: "${area}" (inferred from content).` : "Specify which product area or domain this tension impacts.";
+        }
+      }
+    ]
+  }],
+  ["business-rules", {
+    idPrefix: "SOS",
+    governedDraft: true,
+    descriptionField: "description",
+    defaults: [
+      { key: "severity", value: "medium" },
+      { key: "domain", value: "infer" }
+    ],
+    recommendedRelationTypes: ["governs", "references", "conflicts_with", "related_to"],
+    inferField: (ctx) => {
+      const fields = {};
+      const domain = inferDomain(`${ctx.name} ${ctx.description}`);
+      if (domain) fields.domain = domain;
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      {
+        id: "has-rationale",
+        label: "Rationale provided",
+        check: (ctx) => typeof ctx.data.rationale === "string" && ctx.data.rationale.length > 10,
+        suggestion: () => "Add a rationale explaining why this rule exists via `update-entry`."
+      },
+      {
+        id: "has-domain",
+        label: "Domain specified",
+        check: (ctx) => !!ctx.data.domain && ctx.data.domain !== "",
+        suggestion: (ctx) => {
+          const domain = inferDomain(`${ctx.name} ${ctx.description}`);
+          return domain ? `Set domain \u2014 suggest: "${domain}" (inferred from content).` : "Specify the business domain this rule belongs to.";
+        }
+      }
+    ]
+  }],
+  ["glossary", {
+    idPrefix: "GT",
+    governedDraft: true,
+    descriptionField: "canonical",
+    defaults: [
+      { key: "category", value: "infer" }
+    ],
+    recommendedRelationTypes: ["defines_term_for", "confused_with", "related_to", "references"],
+    inferField: (ctx) => {
+      const fields = {};
+      const area = inferArea(`${ctx.name} ${ctx.description}`);
+      if (area) {
+        const categoryMap = {
+          "Architecture": "Platform & Architecture",
+          "Knowledge Base": "Knowledge Management",
+          "AI & MCP Integration": "AI & Developer Tools",
+          "Developer Experience": "AI & Developer Tools",
+          "Governance & Decision-Making": "Governance & Process",
+          "Analytics & Tracking": "Platform & Architecture",
+          "Security": "Platform & Architecture"
+        };
+        fields.category = categoryMap[area] ?? "";
+      }
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      {
+        id: "has-canonical",
+        label: "Canonical definition provided (>20 chars)",
+        check: (ctx) => {
+          const canonical = ctx.data.canonical;
+          return typeof canonical === "string" && canonical.length > 20;
+        },
+        suggestion: () => "Add a clear canonical definition \u2014 this is the single source of truth for this term."
+      },
+      COMMON_CHECKS.hasRelations,
+      {
+        id: "has-category",
+        label: "Category assigned",
+        check: (ctx) => !!ctx.data.category && ctx.data.category !== "",
+        suggestion: () => "Assign a category (e.g., 'Platform & Architecture', 'Governance & Process')."
+      }
+    ]
+  }],
+  ["decisions", {
+    idPrefix: "DEC",
+    governedDraft: false,
+    descriptionField: "rationale",
+    defaults: [
+      { key: "date", value: "today" },
+      { key: "decidedBy", value: "infer" }
+    ],
+    recommendedRelationTypes: ["informs", "references", "replaces", "related_to"],
+    inferField: (ctx) => {
+      const fields = {};
+      const area = inferArea(`${ctx.name} ${ctx.description}`);
+      if (area) fields.decidedBy = area;
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      {
+        id: "has-rationale",
+        label: "Rationale provided (>30 chars)",
+        check: (ctx) => {
+          const rationale = ctx.data.rationale;
+          return typeof rationale === "string" && rationale.length > 30;
+        },
+        suggestion: () => "Explain why this decision was made \u2014 what was considered and rejected?"
+      },
+      COMMON_CHECKS.hasRelations,
+      {
+        id: "has-date",
+        label: "Decision date recorded",
+        check: (ctx) => !!ctx.data.date && ctx.data.date !== "",
+        suggestion: () => "Record when this decision was made."
+      }
+    ]
+  }]
+]);
+var FALLBACK_PROFILE = {
+  idPrefix: "",
+  governedDraft: false,
+  descriptionField: "description",
+  defaults: [],
+  recommendedRelationTypes: ["related_to", "references"],
+  qualityChecks: [
+    COMMON_CHECKS.clearName,
+    COMMON_CHECKS.hasDescription,
+    COMMON_CHECKS.hasRelations
+  ]
+};
+function generateEntryId(prefix) {
+  if (!prefix) return "";
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let suffix = "";
+  for (let i = 0; i < 6; i++) {
+    suffix += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `${prefix}-${suffix}`;
+}
+function extractSearchTerms(name, description) {
+  const text = `${name} ${description}`;
+  return text.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3).slice(0, 8).join(" ");
+}
+function computeLinkConfidence(candidate, sourceName, sourceDescription, sourceCollection, candidateCollection) {
+  const text = `${sourceName} ${sourceDescription}`.toLowerCase();
+  const candidateName = candidate.name.toLowerCase();
+  let score = 0;
+  if (text.includes(candidateName) && candidateName.length > 3) {
+    score += 40;
+  }
+  const candidateWords = candidateName.split(/\s+/).filter((w) => w.length > 3);
+  const matchingWords = candidateWords.filter((w) => text.includes(w));
+  score += matchingWords.length / Math.max(candidateWords.length, 1) * 30;
+  const HUB_COLLECTIONS = /* @__PURE__ */ new Set(["strategy", "features"]);
+  if (HUB_COLLECTIONS.has(candidateCollection)) {
+    score += 15;
+  }
+  if (candidateCollection !== sourceCollection) {
+    score += 10;
+  }
+  return Math.min(score, 100);
+}
+function inferRelationType(sourceCollection, targetCollection, profile) {
+  const typeMap = {
+    tensions: {
+      glossary: "surfaces_tension_in",
+      "business-rules": "references",
+      strategy: "belongs_to",
+      features: "surfaces_tension_in",
+      decisions: "references"
+    },
+    "business-rules": {
+      glossary: "references",
+      features: "governs",
+      strategy: "belongs_to",
+      tensions: "references"
+    },
+    glossary: {
+      features: "defines_term_for",
+      "business-rules": "references",
+      strategy: "references"
+    },
+    decisions: {
+      features: "informs",
+      "business-rules": "references",
+      strategy: "references",
+      tensions: "references"
+    }
+  };
+  return typeMap[sourceCollection]?.[targetCollection] ?? profile.recommendedRelationTypes[0] ?? "related_to";
+}
+function scoreQuality(ctx, profile) {
+  const checks = profile.qualityChecks.map((qc) => {
+    const passed2 = qc.check(ctx);
+    return {
+      id: qc.id,
+      label: qc.label,
+      passed: passed2,
+      suggestion: passed2 ? void 0 : qc.suggestion?.(ctx)
+    };
+  });
+  const passed = checks.filter((c) => c.passed).length;
+  const total = checks.length;
+  const score = total > 0 ? Math.round(passed / total * 10) : 10;
+  return { score, maxScore: 10, checks };
+}
+function formatQualityReport(result) {
+  const lines = [`## Quality: ${result.score}/${result.maxScore}`];
+  for (const check of result.checks) {
+    const icon = check.passed ? "[x]" : "[ ]";
+    const suggestion = check.passed ? "" : ` -- ${check.suggestion ?? ""}`;
+    lines.push(`${icon} ${check.label}${suggestion}`);
+  }
+  return lines.join("\n");
+}
+async function checkEntryQuality(entryId) {
+  const entry = await mcpQuery("kb.getEntry", { entryId });
+  if (!entry) {
+    return {
+      text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.`,
+      quality: { score: 0, maxScore: 10, checks: [] }
+    };
+  }
+  const collections = await mcpQuery("kb.listCollections");
+  const collMap = /* @__PURE__ */ new Map();
+  for (const c of collections) collMap.set(c._id, c.slug);
+  const collectionSlug = collMap.get(entry.collectionId) ?? "unknown";
+  const profile = PROFILES.get(collectionSlug) ?? FALLBACK_PROFILE;
+  const relations = await mcpQuery("kb.listEntryRelations", { entryId });
+  const linksCreated = [];
+  for (const r of relations) {
+    const otherId = r.fromId === entry._id ? r.toId : r.fromId;
+    linksCreated.push({
+      targetEntryId: otherId,
+      targetName: "",
+      targetCollection: "",
+      relationType: r.type
+    });
+  }
+  const descField = profile.descriptionField;
+  const description = typeof entry.data?.[descField] === "string" ? entry.data[descField] : "";
+  const ctx = {
+    collection: collectionSlug,
+    name: entry.name,
+    description,
+    data: entry.data ?? {},
+    entryId: entry.entryId ?? "",
+    linksCreated,
+    linksSuggested: [],
+    collectionFields: []
+  };
+  const quality = scoreQuality(ctx, profile);
+  const lines = [
+    `# Quality Check: ${entry.entryId ?? entry.name}`,
+    `**${entry.name}** in \`${collectionSlug}\` [${entry.status}]`,
+    "",
+    formatQualityReport(quality)
+  ];
+  if (quality.score < 10) {
+    const failedChecks = quality.checks.filter((c) => !c.passed && c.suggestion);
+    if (failedChecks.length > 0) {
+      lines.push("");
+      lines.push(`_To improve: use \`update-entry\` to fill missing fields, or \`relate-entries\` to add connections._`);
+    }
+  }
+  return { text: lines.join("\n"), quality };
+}
+var GOVERNED_COLLECTIONS = /* @__PURE__ */ new Set([
+  "glossary",
+  "business-rules",
+  "principles",
+  "standards",
+  "strategy",
+  "features"
+]);
+var AUTO_LINK_CONFIDENCE_THRESHOLD = 35;
+var MAX_AUTO_LINKS = 5;
+var MAX_SUGGESTIONS = 5;
+function registerSmartCaptureTools(server2) {
+  server2.registerTool(
+    "smart-capture",
+    {
+      title: "Smart Capture",
+      description: "One-call knowledge capture: creates an entry, auto-links related entries, and returns a quality scorecard. Replaces the multi-step workflow of create-entry + suggest-links + relate-entries. Provide a collection, name, and description \u2014 everything else is inferred or auto-filled.\n\nSupported collections with smart profiles: tensions, business-rules, glossary, decisions.\nAll other collections use sensible defaults (same as quick-capture + auto-linking).\n\nAlways creates as 'draft' for governed collections. Embodies 'Capture Now, Curate Later' (PRI-81cbdq).",
+      inputSchema: {
+        collection: z5.string().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'"),
+        name: z5.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
+        description: z5.string().describe("Full context \u2014 what's happening, why it matters, what you observed"),
+        context: z5.string().optional().describe("Optional additional context (e.g. 'Observed during gather-context calls taking 700ms+')"),
+        entryId: z5.string().optional().describe("Optional custom entry ID (e.g. 'TEN-my-id'). Auto-generated if omitted.")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ collection, name, description, context, entryId }) => {
+      const profile = PROFILES.get(collection) ?? FALLBACK_PROFILE;
+      const col = await mcpQuery("kb.getCollection", { slug: collection });
+      if (!col) {
+        return {
+          content: [{ type: "text", text: `Collection \`${collection}\` not found. Use \`list-collections\` to see available collections.` }]
+        };
+      }
+      const data = {};
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      for (const field of col.fields ?? []) {
+        const key = field.key;
+        if (key === profile.descriptionField) {
+          data[key] = description;
+        } else if (field.type === "array" || field.type === "multi-select") {
+          data[key] = [];
+        } else {
+          data[key] = "";
+        }
+      }
+      for (const def of profile.defaults) {
+        if (def.value === "today") {
+          data[def.key] = today;
+        } else if (def.value !== "infer") {
+          data[def.key] = def.value;
+        }
+      }
+      if (profile.inferField) {
+        const inferred = profile.inferField({
+          collection,
+          name,
+          description,
+          context,
+          data,
+          entryId: "",
+          linksCreated: [],
+          linksSuggested: [],
+          collectionFields: col.fields ?? []
+        });
+        for (const [key, val] of Object.entries(inferred)) {
+          if (val !== void 0 && val !== "") {
+            data[key] = val;
+          }
+        }
+      }
+      if (!data[profile.descriptionField] && !data.description && !data.canonical) {
+        data[profile.descriptionField || "description"] = description;
+      }
+      const status = GOVERNED_COLLECTIONS.has(collection) ? "draft" : "draft";
+      const finalEntryId = entryId ?? generateEntryId(profile.idPrefix);
+      let internalId;
+      try {
+        internalId = await mcpMutation("kb.createEntry", {
+          collectionSlug: collection,
+          entryId: finalEntryId || void 0,
+          name,
+          status,
+          data,
+          createdBy: "smart-capture"
+        });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("Duplicate") || msg.includes("already exists")) {
+          return {
+            content: [{
+              type: "text",
+              text: `# Cannot Capture \u2014 Duplicate Detected
+
+${msg}
+
+Use \`get-entry\` to inspect the existing entry, or \`update-entry\` to modify it.`
+            }]
+          };
+        }
+        throw error;
+      }
+      const linksCreated = [];
+      const linksSuggested = [];
+      const searchQuery = extractSearchTerms(name, description);
+      if (searchQuery) {
+        const [searchResults, allCollections] = await Promise.all([
+          mcpQuery("kb.searchEntries", { query: searchQuery }),
+          mcpQuery("kb.listCollections")
+        ]);
+        const collMap = /* @__PURE__ */ new Map();
+        for (const c of allCollections) collMap.set(c._id, c.slug);
+        const candidates = (searchResults ?? []).filter((r) => r.entryId !== finalEntryId && r._id !== internalId).map((r) => ({
+          ...r,
+          collSlug: collMap.get(r.collectionId) ?? "unknown",
+          confidence: computeLinkConfidence(r, name, description, collection, collMap.get(r.collectionId) ?? "unknown")
+        })).sort((a, b) => b.confidence - a.confidence);
+        for (const c of candidates) {
+          if (linksCreated.length >= MAX_AUTO_LINKS) break;
+          if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
+          if (!c.entryId || !finalEntryId) continue;
+          const relationType = inferRelationType(collection, c.collSlug, profile);
+          try {
+            await mcpMutation("kb.createEntryRelation", {
+              fromEntryId: finalEntryId,
+              toEntryId: c.entryId,
+              type: relationType
+            });
+            linksCreated.push({
+              targetEntryId: c.entryId,
+              targetName: c.name,
+              targetCollection: c.collSlug,
+              relationType
+            });
+          } catch {
+          }
+        }
+        const linkedIds = new Set(linksCreated.map((l) => l.targetEntryId));
+        for (const c of candidates) {
+          if (linksSuggested.length >= MAX_SUGGESTIONS) break;
+          if (linkedIds.has(c.entryId)) continue;
+          if (c.confidence < 10) continue;
+          const preview = extractPreview2(c.data, 80);
+          const reason = c.confidence >= AUTO_LINK_CONFIDENCE_THRESHOLD ? "high relevance (already linked)" : `"${c.name.toLowerCase().split(/\s+/).filter((w) => `${name} ${description}`.toLowerCase().includes(w) && w.length > 3).slice(0, 2).join('", "')}" appears in content`;
+          linksSuggested.push({
+            entryId: c.entryId,
+            name: c.name,
+            collection: c.collSlug,
+            reason,
+            preview
+          });
+        }
+      }
+      const captureCtx = {
+        collection,
+        name,
+        description,
+        context,
+        data,
+        entryId: finalEntryId,
+        linksCreated,
+        linksSuggested,
+        collectionFields: col.fields ?? []
+      };
+      const quality = scoreQuality(captureCtx, profile);
+      const lines = [
+        `# Captured: ${finalEntryId || name}`,
+        `**${name}** added to \`${collection}\` as \`${status}\``
+      ];
+      if (linksCreated.length > 0) {
+        lines.push("");
+        lines.push(`## Auto-linked (${linksCreated.length})`);
+        for (const link of linksCreated) {
+          lines.push(`- -> **${link.relationType}** ${link.targetEntryId}: ${link.targetName} [${link.targetCollection}]`);
+        }
+      }
+      if (linksSuggested.length > 0) {
+        lines.push("");
+        lines.push("## Suggested links (review and use relate-entries)");
+        for (let i = 0; i < linksSuggested.length; i++) {
+          const s = linksSuggested[i];
+          const preview = s.preview ? ` \u2014 ${s.preview}` : "";
+          lines.push(`${i + 1}. **${s.entryId ?? "(no ID)"}**: ${s.name} [${s.collection}]${preview}`);
+        }
+      }
+      lines.push("");
+      lines.push(formatQualityReport(quality));
+      const failedChecks = quality.checks.filter((c) => !c.passed);
+      if (failedChecks.length > 0) {
+        lines.push("");
+        lines.push(`_To improve: \`update-entry entryId="${finalEntryId}"\` to fill missing fields._`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "quality-check",
+    {
+      title: "Quality Check",
+      description: "Score an existing knowledge entry against collection-specific quality criteria. Returns a scorecard (X/10) with specific, actionable suggestions for improvement. Checks: name clarity, description completeness, relation connectedness, and collection-specific fields.\n\nUse after creating entries to assess their quality, or to audit existing entries.",
+      inputSchema: {
+        entryId: z5.string().describe("Entry ID to check, e.g. 'TEN-graph-db', 'GT-019', 'SOS-006'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ entryId }) => {
+      const result = await checkEntryQuality(entryId);
+      return { content: [{ type: "text", text: result.text }] };
+    }
+  );
+}
+function extractPreview2(data, maxLen) {
+  if (!data || typeof data !== "object") return "";
+  const raw = data.description ?? data.canonical ?? data.detail ?? data.rule ?? "";
+  if (typeof raw !== "string" || !raw) return "";
+  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");
+}
+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."
+    );
+  }
+  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- **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 = ["# 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)
+
+${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 z6 } 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')") },
+    async ({ domain }) => {
+      const entries = await mcpQuery("kb.listEntries", { collectionSlug: "business-rules" });
+      const rules = entries.filter((e) => e.data?.domain === domain);
+      if (rules.length === 0) {
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `No business rules found for domain "${domain}". Use the list-entries tool with collection "business-rules" to see available domains.`
+              }
+            }
+          ]
+        };
+      }
+      const rulesText = rules.map(
+        (r) => `### ${r.entryId ?? ""}: ${r.name}
+Status: ${r.status} | Severity: ${r.data?.severity ?? "unknown"}
+Description: ${r.data?.description ?? ""}
+Data Impact: ${r.data?.dataImpact ?? ""}
+Platforms: ${(r.data?.platforms ?? []).join(", ")}
+` + (r.data?.conflictWith ? `CONFLICT: ${r.data.conflictWith.rule} \u2014 ${r.data.conflictWith.nature}
+` : "")
+      ).join("\n---\n\n");
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Review the current code or design against the following business rules for the "${domain}" domain.
+
+For each rule, assess:
+1. Is the current implementation compliant?
+2. Are there potential violations or edge cases?
+3. What specific changes would be needed for compliance?
+
+Business Rules:
+
+${rulesText}
+
+Provide a structured review with a compliance status for each rule (COMPLIANT / AT RISK / VIOLATION / NOT APPLICABLE).`
+            }
+          }
+        ]
+      };
+    }
+  );
+  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')") },
+    async ({ names }) => {
+      const terms = await mcpQuery("kb.listEntries", { collectionSlug: "glossary" });
+      const glossaryContext = terms.map(
+        (t) => `${t.name} (${t.entryId ?? ""}) [${t.status}]: ${t.data?.canonical ?? ""}` + (t.data?.confusedWith?.length > 0 ? ` \u2014 Often confused with: ${t.data.confusedWith.join(", ")}` : "") + (t.data?.codeMapping?.length > 0 ? `
+  Code mappings: ${t.data.codeMapping.map((m) => `${m.platform}:${m.field}`).join(", ")}` : "")
+      ).join("\n");
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Check the following names against the glossary for terminology alignment:
+
+Names to check: ${names}
+
+Glossary (canonical terms):
+${glossaryContext}
+
+For each name:
+1. Does it match a canonical term? If so, which one?
+2. Is there terminology drift? (e.g. using "vendor" instead of "supplier", "compliance" instead of "conformance")
+3. Suggest the canonical alternative if drift is detected.
+4. Flag any names that don't have a corresponding glossary term (might need one).
+
+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...')") },
+    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);
+      const recentContext = sorted.length > 0 ? sorted.map((d) => `- [${d.status}] ${d.name} (${d.data?.date ?? "no date"})`).join("\n") : "No previous decisions recorded.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Draft a structured decision record from the following context:
+
+"${context}"
+
+Recent decisions for reference:
+${recentContext}
+
+Structure the decision record with:
+1. **Title**: Concise decision statement
+2. **Decided by**: Who made or approved this decision
+3. **Date**: When it was decided
+4. **Status**: decided / proposed / revisited
+5. **Rationale**: Why this decision was made, including trade-offs considered
+6. **Alternatives considered**: What else was on the table
+7. **Related rules or tensions**: Any business rules or tensions this connects to
+
+After drafting, I can log it using the create-entry tool with collection "decisions".`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server2.prompt(
+    "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')")
+    },
+    async ({ observation, domain }) => {
+      const allRules = await mcpQuery("kb.listEntries", { collectionSlug: "business-rules" });
+      const existingRules = allRules.filter((r) => r.data?.domain === domain);
+      const existingContext = existingRules.length > 0 ? existingRules.map((r) => `${r.entryId ?? ""}: ${r.name} [${r.status}] \u2014 ${r.data?.description ?? ""}`).join("\n") : "No existing rules for this domain.";
+      const highestRuleNum = allRules.map((r) => parseInt((r.entryId ?? "").replace(/^[A-Z]+-/, ""), 10)).filter((n) => !isNaN(n)).sort((a, b) => b - a)[0] || 0;
+      const nextRuleId = `SOS-${String(highestRuleNum + 1).padStart(3, "0")}`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Draft a business rule based on this observation:
+
+"${observation}"
+
+Domain: ${domain}
+Suggested rule ID: ${nextRuleId}
+
+Existing rules in this domain:
+${existingContext}
+
+Draft the rule with these fields:
+1. **entryId**: ${nextRuleId}
+2. **name**: Concise rule title
+3. **data.description**: What the rule states
+4. **data.rationale**: Why this rule matters
+5. **data.dataImpact**: How this affects data models, APIs, or storage
+6. **data.severity**: high / medium / low
+7. **data.platforms**: Which platforms are affected
+8. **data.relatedRules**: Any related existing rules
+
+Make sure the rule is consistent with existing rules and doesn't contradict them. After drafting, I can create it using the create-entry tool with collection "business-rules".`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// 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 trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      process.env[trimmed.slice(0, eqIdx)] ??= trimmed.slice(eqIdx + 1);
+    }
+  } catch {
+  }
+}
+bootstrapCloudMode();
+var SERVER_VERSION = "1.0.0";
+initAnalytics();
+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." : "";
+  process.stderr.write(`[MCP] Startup failed: ${err.message}${hint}
+`);
+  process.exit(1);
+}
+trackSessionStarted(
+  process.env.WORKSPACE_SLUG ?? "unknown",
+  workspaceId,
+  SERVER_VERSION
+);
+var server = new McpServer2(
+  {
+    name: "Product Brain",
+    version: SERVER_VERSION
+  },
+  {
+    capabilities: { logging: {} },
+    instructions: [
+      "ProductBrain \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`",
+      "or use the `name-check` prompt to validate names against the glossary.",
+      "",
+      "Workflow:",
+      "  1. Verify: call `health` to confirm connectivity.",
+      "  2. Terminology: fetch `productbrain://terminology` or use `name-check` prompt for naming questions.",
+      "  3. Discover: use `kb-search` to find entries by text, or `list-entries` to browse a collection.",
+      "  4. Drill in: use `get-entry` for full details \u2014 data, labels, relations, history.",
+      "  5. Capture: use `smart-capture` to create entries \u2014 it auto-links related entries and",
+      "     returns a quality scorecard in one call. Use `create-entry` only when you need",
+      "     full control over every field.",
+      "  6. Connect: use `suggest-links` then `relate-entries` to build the graph.",
+      "  7. Quality: use `quality-check` to assess entry completeness.",
+      "  8. Debug: use `mcp-audit` to see what backend calls happened this session.",
+      "",
+      "Always prefer `smart-capture` over `create-entry` or `quick-capture` for new entries.",
+      "Always prefer kb-search or list-entries before get-entry \u2014 discover, then drill in.",
+      "",
+      "Orientation:",
+      "  When you need to understand the system \u2014 architecture, data model, rules,",
+      "  or analytics \u2014 fetch the `productbrain://orientation` resource first.",
+      "  It gives you the map. Then use the appropriate tool to drill in."
+    ].join("\n")
+  }
+);
+registerKnowledgeTools(server);
+registerLabelTools(server);
+registerHealthTools(server);
+registerVerifyTools(server);
+registerSmartCaptureTools(server);
+registerResources(server);
+registerPrompts(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+async function gracefulShutdown() {
+  await shutdownAnalytics();
+  process.exit(0);
+}
+process.on("SIGINT", gracefulShutdown);
+process.on("SIGTERM", gracefulShutdown);
+//# sourceMappingURL=index.js.map