@productbrain/mcp 0.0.1-beta.5 → 0.0.1-beta.7

package/dist/index.js

@@ -1,4 +1,27 @@
 #!/usr/bin/env node
+import {
+  bootstrap,
+  closeAgentSession,
+  getAgentSessionId,
+  getAuditLog,
+  getWorkspaceContext,
+  getWorkspaceId,
+  initAnalytics,
+  isSessionOriented,
+  mcpCall,
+  mcpMutation,
+  mcpQuery,
+  orphanAgentSession,
+  recordSessionActivity,
+  recoverSessionState,
+  registerSmartCaptureTools,
+  requireWriteAccess,
+  setSessionOriented,
+  shutdownAnalytics,
+  startAgentSession,
+  trackSessionStarted
+} from "./chunk-6ZSCQINU.js";
+
 // src/index.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve3 } from "path";
@@ -7,179 +30,6 @@ 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] No PostHog key \u2014 tracking disabled (set SYNERGYOS_POSTHOG_KEY at build time for publish)\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://trustworthy-kangaroo-277.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 ?? "";
@@ -195,7 +45,7 @@ function registerKnowledgeTools(server2) {
       annotations: { readOnlyHint: true }
     },
     async () => {
-      const collections = await mcpQuery("kb.listCollections");
+      const collections = await mcpQuery("chain.listCollections");
       if (collections.length === 0) {
         return { content: [{ type: "text", text: "No collections found in this workspace." }] };
       }
@@ -230,10 +80,10 @@ ${formatted}` }]
     async ({ collection, status, tag, label }) => {
       let entries;
       if (label) {
-        entries = await mcpQuery("kb.listEntriesByLabel", { labelSlug: label });
+        entries = await mcpQuery("chain.listEntriesByLabel", { labelSlug: label });
         if (status) entries = entries.filter((e) => e.status === status);
       } else {
-        entries = await mcpQuery("kb.listEntries", {
+        entries = await mcpQuery("chain.listEntries", {
           collectionSlug: collection,
           status,
           tag
@@ -267,7 +117,7 @@ ${formatted}` }]
       annotations: { readOnlyHint: true }
     },
     async ({ entryId }) => {
-      const entry = await mcpQuery("kb.getEntry", { entryId });
+      const entry = await mcpQuery("chain.getEntry", { entryId });
       if (!entry) {
         return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }] };
       }
@@ -324,21 +174,26 @@ ${formatted}` }]
     },
     async ({ entryId, name, status, data, order, autoPublish }) => {
       try {
-        const id = await mcpMutation("kb.updateEntry", {
+        requireWriteAccess();
+        const id = await mcpMutation("chain.updateEntry", {
           entryId,
           name,
           status,
           data,
           order,
-          autoPublish
+          autoPublish,
+          changedBy: getAgentSessionId() ? `agent:${getAgentSessionId()}` : void 0
         });
+        await recordSessionActivity({ entryModified: entryId });
+        const wsCtx = await getWorkspaceContext();
         const mode = autoPublish ? "published" : "saved as draft";
         return {
           content: [{ type: "text", text: `# Entry Updated
 
 **${entryId}** has been ${mode}.
 
-Internal ID: ${id}` }]
+Internal ID: ${id}
+**Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})` }]
         };
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
@@ -380,8 +235,8 @@ Process criteria (TBD): e.g. 3+ users approved, or 7 days without valid concerns
       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")
+        mcpQuery("chain.searchEntries", { query, collectionSlug: collection, status }),
+        mcpQuery("chain.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.` }] };
@@ -430,7 +285,7 @@ ${footer}` }]
       annotations: { readOnlyHint: true }
     },
     async ({ entryId }) => {
-      const history = await mcpQuery("kb.listEntryHistory", { entryId });
+      const history = await mcpQuery("chain.listEntryHistory", { entryId });
       if (history.length === 0) {
         return { content: [{ type: "text", text: `No history found for \`${entryId}\`.` }] };
       }
@@ -459,18 +314,73 @@ ${formatted}` }]
       annotations: { destructiveHint: false }
     },
     async ({ from, to, type }) => {
-      await mcpMutation("kb.createEntryRelation", {
+      requireWriteAccess();
+      await mcpMutation("chain.createEntryRelation", {
         fromEntryId: from,
         toEntryId: to,
         type
       });
+      await recordSessionActivity({ relationCreated: true });
+      const wsCtx = await getWorkspaceContext();
       return {
         content: [{ type: "text", text: `# Relation Created
 
-**${from}** \u2014[${type}]\u2192 **${to}**` }]
+**${from}** \u2014[${type}]\u2192 **${to}**
+**Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})` }]
       };
     }
   );
+  server2.registerTool(
+    "batch-relate",
+    {
+      title: "Batch Link Entries",
+      description: "Create multiple relations in one call. Accepts an array of {from, to, type} objects. Use after suggest-links to apply several suggestions at once instead of calling relate-entries repeatedly.\n\nEach relation is created independently \u2014 if one fails, the others still succeed. Returns a summary of created and failed relations.",
+      inputSchema: {
+        relations: z.array(z.object({
+          from: z.string().describe("Source entry ID"),
+          to: z.string().describe("Target entry ID"),
+          type: z.string().describe("Relation type")
+        })).min(1).max(20).describe("Array of relations to create")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ relations }) => {
+      requireWriteAccess();
+      const results = [];
+      for (const rel of relations) {
+        try {
+          await mcpMutation("chain.createEntryRelation", {
+            fromEntryId: rel.from,
+            toEntryId: rel.to,
+            type: rel.type
+          });
+          results.push({ ...rel, ok: true });
+        } catch (e) {
+          results.push({ ...rel, ok: false, error: e.message || "Unknown error" });
+        }
+      }
+      const created = results.filter((r) => r.ok);
+      const failed = results.filter((r) => !r.ok);
+      const lines = [`# Batch Link Results
+`];
+      lines.push(`**${created.length}** created, **${failed.length}** failed out of ${relations.length} total.
+`);
+      if (created.length > 0) {
+        lines.push("## Created");
+        for (const r of created) {
+          lines.push(`- **${r.from}** \u2014[${r.type}]\u2192 **${r.to}**`);
+        }
+      }
+      if (failed.length > 0) {
+        lines.push("");
+        lines.push("## Failed");
+        for (const r of failed) {
+          lines.push(`- **${r.from}** \u2192 **${r.to}** (${r.type}): _${r.error}_`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
   server2.registerTool(
     "find-related",
     {
@@ -483,11 +393,11 @@ ${formatted}` }]
       annotations: { readOnlyHint: true }
     },
     async ({ entryId, direction }) => {
-      const relations = await mcpQuery("kb.listEntryRelations", { entryId });
+      const relations = await mcpQuery("chain.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 });
+      const sourceEntry = await mcpQuery("chain.getEntry", { entryId });
       if (!sourceEntry) {
         return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }] };
       }
@@ -502,12 +412,12 @@ ${formatted}` }]
       }
       const otherEntries = /* @__PURE__ */ new Map();
       for (const id of otherIds) {
-        const entry = await mcpQuery("kb.getEntry", { id });
+        const entry = await mcpQuery("chain.getEntry", { id });
         if (entry) {
           otherEntries.set(entry._id, { entryId: entry.entryId, name: entry.name, collectionId: entry.collectionId });
         }
       }
-      const collections = await mcpQuery("kb.listCollections");
+      const collections = await mcpQuery("chain.listCollections");
       const collMap = /* @__PURE__ */ new Map();
       for (const c of collections) collMap.set(c._id, c.slug);
       const lines = [`# Relations for ${entryId}: ${sourceEntry.name}`, ""];
@@ -549,19 +459,67 @@ ${formatted}` }]
     "gather-context",
     {
       title: "Gather Context",
-      description: "Assemble knowledge context in one call. Two modes:\n\n1. **By entry** (entryId): Traverse the knowledge graph around a specific entry. Returns all related entries grouped by collection.\n2. **By task** (task): Auto-load relevant domain knowledge for a natural-language task. Searches the chain, traverses the graph, and returns ranked entries with confidence scores.\n\nUse mode 1 when you have a specific entry ID. Use mode 2 at the start of a conversation to ground the agent in domain context before writing code or making recommendations.",
+      description: "Assemble knowledge context in one call. Three modes:\n\n1. **By entry** (entryId): Traverse the knowledge graph around a specific entry. Returns all related entries grouped by collection.\n2. **By task** (task): Auto-load relevant domain knowledge for a natural-language task. Searches the chain, traverses the graph, and returns ranked entries with confidence scores.\n3. **Graph mode** (entryId + mode='graph'): Enhanced graph traversal with provenance \u2014 each entry includes the full path that led to it (via what relations, from what starting point).\n\nUse mode 1/3 when you have a specific entry ID. Use mode 2 at the start of a conversation to ground the agent in domain context before writing code or making recommendations.",
       inputSchema: {
         entryId: z.string().optional().describe("Entry ID for graph traversal, e.g. 'FEAT-001', 'GT-019'"),
         task: z.string().optional().describe("Natural-language task description for auto-loading relevant context"),
+        mode: z.enum(["search", "graph"]).default("search").optional().describe("'search' (default, backward-compatible) or 'graph' (enhanced with provenance paths)"),
         maxHops: z.number().min(1).max(3).default(2).describe("How many relation hops to traverse (1=direct only, 2=default, 3=wide net)"),
         maxResults: z.number().min(1).max(25).default(10).optional().describe("Max entries to return in task mode (default 10)")
       },
       annotations: { readOnlyHint: true }
     },
-    async ({ entryId, task, maxHops, maxResults }) => {
+    async ({ entryId, task, mode, maxHops, maxResults }) => {
       if (!entryId && !task) {
         return { content: [{ type: "text", text: "Provide either `entryId` (graph traversal) or `task` (auto-load context for a task)." }] };
       }
+      if (entryId && mode === "graph") {
+        const result2 = await mcpQuery("chain.graphGatherContext", {
+          entryId,
+          maxHops: maxHops ?? 2
+        });
+        if (!result2?.root) {
+          return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }] };
+        }
+        if (result2.context.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: `# Context for ${result2.root.entryId}: ${result2.root.name}
+
+_No relations found._ This entry is not yet connected to the knowledge graph.
+
+Use \`suggest-links\` to discover potential connections.`
+            }]
+          };
+        }
+        const byCollection2 = /* @__PURE__ */ new Map();
+        for (const entry of result2.context) {
+          const key = entry.collectionName;
+          if (!byCollection2.has(key)) byCollection2.set(key, []);
+          byCollection2.get(key).push(entry);
+        }
+        const lines2 = [
+          `# Context for ${result2.root.entryId}: ${result2.root.name} (graph mode)`,
+          `_${result2.totalFound} related entries across ${byCollection2.size} collections (${result2.hopsTraversed} hops)_`,
+          ""
+        ];
+        for (const [collName, entries] of byCollection2) {
+          lines2.push(`## ${collName} (${entries.length})`);
+          for (const e of entries) {
+            const arrow = e.relationDirection === "outgoing" ? "\u2192" : "\u2190";
+            const id = e.entryId ? `${e.entryId}: ` : "";
+            const hopLabel = e.hop > 1 ? ` (hop ${e.hop})` : "";
+            const provenancePath = e.provenance && e.provenance.length > 1 ? `
+  _Path: ${e.provenance.map((p) => `${p.entryId ?? p.name} [${p.relationType}]`).join(" \u2192 ")}_` : "";
+            const preview = e.preview ? `
+  ${e.preview.substring(0, 120)}` : "";
+            lines2.push(`- ${arrow} **${e.relationType}** ${id}${e.name}${hopLabel}${provenancePath}${preview}`);
+          }
+          lines2.push("");
+        }
+        return { content: [{ type: "text", text: lines2.join("\n") }] };
+      }
       if (task && !entryId) {
         await server2.sendLoggingMessage({
           level: "info",
@@ -569,7 +527,7 @@ ${formatted}` }]
           logger: "product-brain"
         });
         const searchTerms = task.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3).slice(0, 12).join(" ");
-        const searchResults = await mcpQuery("kb.searchEntries", {
+        const searchResults = await mcpQuery("chain.searchEntries", {
           query: searchTerms
         });
         if (!searchResults || searchResults.length === 0) {
@@ -602,7 +560,7 @@ _Consider capturing domain knowledge discovered during this task via \`capture\`
           });
           if (hit.entryId) {
             try {
-              const graph = await mcpQuery("kb.gatherContext", {
+              const graph = await mcpQuery("chain.gatherContext", {
                 entryId: hit.entryId,
                 maxHops: maxHops ?? 2
               });
@@ -652,7 +610,7 @@ _Consider capturing domain knowledge discovered during this task via \`capture\`
         lines2.push(`_Use \`get-entry\` for full details on any entry._`);
         return { content: [{ type: "text", text: lines2.join("\n") }] };
       }
-      const result = await mcpQuery("kb.gatherContext", { entryId, maxHops });
+      const result = await mcpQuery("chain.gatherContext", { entryId, maxHops });
       if (!result?.root) {
         return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }] };
       }
@@ -696,61 +654,213 @@ Use \`suggest-links\` to discover potential connections, or \`relate-entries\` t
     "suggest-links",
     {
       title: "Suggest Links",
-      description: "Discover potential connections for an entry by scanning the chain 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.",
+      description: "Discover potential connections for an entry using graph-aware intelligence. Accepts an entry ID (e.g. 'FEAT-001') OR an entry name (e.g. 'Chain Intelligence'). Traverses the knowledge graph (2-hop BFS) and scores candidates by graph distance, text similarity, and relation type fit. Also finds text-similar entries not yet in the graph.\n\nReturns ranked suggestions with confidence scores, recommended relation types, and graph-path reasoning explaining WHY each connection matters.\n\nThis is a discovery tool \u2014 review suggestions and use relate-entries to create the ones that make sense.",
       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")
+        entryId: z.string().describe("Entry ID (e.g. 'FEAT-001') or entry name (e.g. 'Chain Intelligence') to find suggestions for"),
+        limit: z.number().min(1).max(20).default(10).describe("Max number of suggestions to return"),
+        depth: z.number().min(1).max(3).default(2).describe("Graph traversal depth: 1=direct neighbors only, 2=default, 3=wide net")
       },
       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 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 chain 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.` }] };
+    async ({ entryId, limit, depth }) => {
+      const result = await mcpQuery("chain.graphSuggestLinks", {
+        entryId,
+        maxHops: depth ?? 2,
+        limit: limit ?? 10
+      });
+      if (!result || !result.suggestions || result.suggestions.length === 0) {
+        return { content: [{ type: "text", text: `No suggestions found for \`${entryId}\` \u2014 it may already be well-connected, or no similar entries exist.` }] };
       }
+      const resolved = result.resolvedEntry;
+      const resolvedLabel = resolved ? `\`${resolved.entryId ?? resolved.name}\` (${resolved.name})` : `\`${entryId}\``;
+      const suggestions = result.suggestions;
+      const graphCount = suggestions.filter((s) => s.graphDistance > 0).length;
+      const textCount = suggestions.filter((s) => s.graphDistance === -1).length;
+      const sourceId = resolved?.entryId ?? entryId;
       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._`,
+        `# Link Suggestions for ${resolvedLabel}`,
+        `_${suggestions.length} potential connections (${graphCount} via graph, ${textCount} via text similarity)._`,
         ""
       ];
-      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}`);
+      const top3 = suggestions.slice(0, 3);
+      lines.push("## Quick Wins (top 3)");
+      const batchArgs = [];
+      for (const s of top3) {
+        const tid = s.entryId ?? "(no ID)";
+        const relType = s.recommendedRelationType || "related_to";
+        lines.push(`- **${tid}**: ${s.name} [${s.collectionSlug}] \u2014 ${s.score}/100 \u2192 \`${relType}\``);
+        if (s.entryId) batchArgs.push(`{from:"${sourceId}",to:"${tid}",type:"${relType}"}`);
       }
       lines.push("");
-      lines.push("**To link:** `relate-entries from='FEAT-001' to='GT-019' type='defines_term_for'`");
+      if (batchArgs.length > 0) {
+        lines.push(`**Link all 3:** \`batch-relate relations=[${batchArgs.join(",")}]\``);
+        lines.push("");
+      }
+      if (suggestions.length > 3) {
+        lines.push("## All Suggestions");
+        for (let i = 0; i < suggestions.length; i++) {
+          const s = suggestions[i];
+          const scoreBar = "\u2588".repeat(Math.round(s.score / 10)) + "\u2591".repeat(10 - Math.round(s.score / 10));
+          const hopLabel = s.graphDistance > 0 ? `${s.graphDistance}-hop` : "text";
+          const recType = s.recommendedRelationType !== "related_to" ? ` \u2192 \`${s.recommendedRelationType}\`` : "";
+          lines.push(`${i + 1}. **${s.entryId ?? "(no ID)"}**: ${s.name} [${s.collectionSlug}] (${hopLabel})`);
+          lines.push(`   ${scoreBar} ${s.score}/100${recType}`);
+          if (s.preview) {
+            lines.push(`   ${s.preview}`);
+          }
+          lines.push(`   _${s.reasoning}_`);
+        }
+      }
       lines.push("");
-      lines.push("_Recommended relation types: governs, defines_term_for, belongs_to, informs, surfaces_tension_in, related_to, depends_on_");
+      lines.push(`**To link one:** \`relate-entries from="${sourceId}" to="{target_id}" type="{type}"\``);
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "create-collection",
+    {
+      title: "Create Collection",
+      description: "Create a new knowledge collection in the workspace. Collections define the structure for entries (like Notion databases or Capacity boards). Provide a slug, name, and field schema.\n\nUse this when setting up a workspace or when the user wants to track a new type of knowledge. Use `list-collections` first to see what already exists.",
+      inputSchema: {
+        slug: z.string().describe("URL-safe identifier, e.g. 'glossary', 'tech-debt', 'api-endpoints'"),
+        name: z.string().describe("Display name, e.g. 'Glossary', 'Tech Debt', 'API Endpoints'"),
+        description: z.string().optional().describe("What this collection is for"),
+        icon: z.string().optional().describe("Emoji icon for the collection"),
+        fields: z.array(z.object({
+          key: z.string().describe("Field key, e.g. 'description', 'severity', 'status'"),
+          label: z.string().describe("Display label, e.g. 'Description', 'Severity'"),
+          type: z.string().describe("Field type: 'string', 'select', 'array', 'number', 'boolean'"),
+          required: z.boolean().optional().describe("Whether this field is required"),
+          options: z.array(z.string()).optional().describe("Options for 'select' type fields"),
+          searchable: z.boolean().optional().describe("Whether this field is included in full-text search")
+        })).describe("Field definitions for the collection schema")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ slug, name, description, icon, fields }) => {
+      requireWriteAccess();
+      try {
+        await mcpMutation("chain.createCollection", {
+          slug,
+          name,
+          description,
+          icon,
+          fields,
+          isDefault: false,
+          createdBy: getAgentSessionId() ? `agent:${getAgentSessionId()}` : "mcp"
+        });
+        const fieldList = fields.map((f) => `  - \`${f.key}\` (${f.type}${f.required ? ", required" : ""}${f.searchable ? ", searchable" : ""})`).join("\n");
+        return {
+          content: [{
+            type: "text",
+            text: `# Collection Created: ${name}
+
+**Slug:** \`${slug}\`
+` + (description ? `**Description:** ${description}
+` : "") + `
+**Fields:**
+${fieldList}
+
+You can now capture entries: \`capture collection="${slug}" name="..." description="..."\``
+          }]
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("already exists")) {
+          return {
+            content: [{
+              type: "text",
+              text: `Collection \`${slug}\` already exists. Use \`update-collection\` to modify it, or choose a different slug.`
+            }]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server2.registerTool(
+    "update-collection",
+    {
+      title: "Update Collection",
+      description: "Update an existing collection's name, description, icon, or field schema. Only provide the fields you want to change. Use `list-collections` to see current state.",
+      inputSchema: {
+        slug: z.string().describe("Collection slug to update, e.g. 'glossary', 'tech-debt'"),
+        name: z.string().optional().describe("New display name"),
+        description: z.string().optional().describe("New description"),
+        icon: z.string().optional().describe("New emoji icon"),
+        fields: z.array(z.object({
+          key: z.string(),
+          label: z.string(),
+          type: z.string(),
+          required: z.boolean().optional(),
+          options: z.array(z.string()).optional(),
+          searchable: z.boolean().optional()
+        })).optional().describe("Replacement field schema (replaces all fields \u2014 include existing fields you want to keep)")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ slug, name, description, icon, fields }) => {
+      requireWriteAccess();
+      await mcpMutation("chain.updateCollection", {
+        slug,
+        ...name !== void 0 && { name },
+        ...description !== void 0 && { description },
+        ...icon !== void 0 && { icon },
+        ...fields !== void 0 && { fields }
+      });
+      const changes = [name && "name", description && "description", icon && "icon", fields && "fields"].filter(Boolean).join(", ");
+      return {
+        content: [{
+          type: "text",
+          text: `# Collection Updated: \`${slug}\`
+
+Changed: ${changes || "no changes"}.
+
+Use \`list-collections\` to verify the result.`
+        }]
+      };
+    }
+  );
+  server2.registerTool(
+    "commit-entry",
+    {
+      title: "Commit Entry to Chain",
+      description: "Promote a draft entry to committed status (SSOT on the Chain). Runs a keyword contradiction check against governance entries before committing. Warnings are advisory \u2014 they do not block the commit.\n\nUse after capture + suggest-links + relate-entries to finalize an entry.",
+      inputSchema: {
+        entryId: z.string().describe("Entry ID to commit, e.g. 'TEN-abc123', 'GT-019'")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ entryId }) => {
+      requireWriteAccess();
+      const { runContradictionCheck } = await import("./smart-capture-SEINMTTR.js");
+      const entry = await mcpQuery("chain.getEntry", { entryId });
+      if (!entry) {
+        return {
+          content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }]
+        };
+      }
+      const descField = entry.data?.description ?? entry.data?.canonical ?? entry.data?.rationale ?? "";
+      const warnings = await runContradictionCheck(entry.name, descField);
+      if (warnings.length > 0) {
+        await recordSessionActivity({ contradictionWarning: true });
+      }
+      const result = await mcpMutation("chain.commitEntry", { entryId });
+      await recordSessionActivity({ entryModified: entryId });
+      const wsCtx = await getWorkspaceContext();
+      const lines = [
+        `# Committed: ${entryId}`,
+        `**${entry.name}** promoted to SSOT on the Chain.`,
+        `**Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})`
+      ];
+      if (warnings.length > 0) {
+        lines.push("");
+        lines.push("\u26A0 Contradiction check: proposed entry matched existing governance entries:");
+        for (const w of warnings) {
+          lines.push(`- ${w.name} (${w.collection}, ${w.entryId}) \u2014 has 'governs' relation to ${w.governsCount} entries`);
+        }
+        lines.push("Run gather-context on these entries before committing.");
+      }
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
   );
@@ -778,7 +888,7 @@ function registerLabelTools(server2) {
     },
     async ({ action, slug, name, color, description, parentSlug, isGroup, order, entryId }) => {
       if (action === "list") {
-        const labels = await mcpQuery("kb.listLabels");
+        const labels = await mcpQuery("chain.listLabels");
         if (labels.length === 0) {
           return { content: [{ type: "text", text: "No labels defined in this workspace yet." }] };
         }
@@ -813,26 +923,26 @@ function registerLabelTools(server2) {
         }
         let parentId;
         if (parentSlug) {
-          const labels = await mcpQuery("kb.listLabels");
+          const labels = await mcpQuery("chain.listLabels");
           const parent = labels.find((l) => l.slug === parentSlug);
           if (!parent) {
             return { content: [{ type: "text", text: `Parent label \`${parentSlug}\` not found. Use \`labels action=list\` to see available groups.` }] };
           }
           parentId = parent._id;
         }
-        await mcpMutation("kb.createLabel", { slug, name, color, description, parentId, isGroup, order });
+        await mcpMutation("chain.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 });
+        await mcpMutation("chain.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 });
+        await mcpMutation("chain.deleteLabel", { slug });
         return { content: [{ type: "text", text: `# Label Deleted
 
 \`${slug}\` removed from all entries and deleted.` }] };
@@ -842,10 +952,10 @@ function registerLabelTools(server2) {
           return { content: [{ type: "text", text: "An `entryId` is required for apply/remove actions." }] };
         }
         if (action === "apply") {
-          await mcpMutation("kb.applyLabel", { entryId, labelSlug: slug });
+          await mcpMutation("chain.applyLabel", { entryId, labelSlug: slug });
           return { content: [{ type: "text", text: `Label \`${slug}\` applied to **${entryId}**.` }] };
         }
-        await mcpMutation("kb.removeLabel", { entryId, labelSlug: slug });
+        await mcpMutation("chain.removeLabel", { entryId, labelSlug: slug });
         return { content: [{ type: "text", text: `Label \`${slug}\` removed from **${entryId}**.` }] };
       }
       return { content: [{ type: "text", text: "Unknown action." }] };
@@ -856,23 +966,25 @@ function registerLabelTools(server2) {
 // 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",
+  "chain.getEntry": "read",
+  "chain.listEntries": "read",
+  "chain.listEntryHistory": "read",
+  "chain.listEntryRelations": "read",
+  "chain.listEntriesByLabel": "read",
+  "chain.searchEntries": "search",
+  "chain.createEntry": "write",
+  "chain.updateEntry": "write",
+  "chain.createEntryRelation": "write",
+  "chain.applyLabel": "label",
+  "chain.removeLabel": "label",
+  "chain.createLabel": "label",
+  "chain.updateLabel": "label",
+  "chain.deleteLabel": "label",
+  "chain.createCollection": "write",
+  "chain.updateCollection": "write",
+  "chain.listCollections": "meta",
+  "chain.getCollection": "meta",
+  "chain.listLabels": "meta",
   "resolveWorkspace": "meta"
 };
 function categorize(fn) {
@@ -884,23 +996,23 @@ function formatDuration(ms) {
   const secs = Math.round(ms % 6e4 / 1e3);
   return `${mins}m ${secs}s`;
 }
-function buildSessionSummary(log2) {
-  if (log2.length === 0) return "";
+function buildSessionSummary(log) {
+  if (log.length === 0) return "";
   const byCategory = /* @__PURE__ */ new Map();
   let errorCount = 0;
   let writeCreates = 0;
   let writeUpdates = 0;
-  for (const entry of log2) {
+  for (const entry of log) {
     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++;
+    if (entry.fn === "chain.createEntry" && entry.status === "ok") writeCreates++;
+    if (entry.fn === "chain.updateEntry" && entry.status === "ok") writeUpdates++;
   }
-  const firstTs = new Date(log2[0].ts).getTime();
-  const lastTs = new Date(log2[log2.length - 1].ts).getTime();
+  const firstTs = new Date(log[0].ts).getTime();
+  const lastTs = new Date(log[log.length - 1].ts).getTime();
   const duration = formatDuration(lastTs - firstTs);
   const lines = [`# Session Summary (${duration})
 `];
@@ -915,7 +1027,7 @@ function buildSessionSummary(log2) {
     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(", ");
+    const detail = [...fnCounts.entries()].sort((a, b) => b[1] - a[1]).map(([fn, count]) => `${fn.replace("chain.", "")} x${count}`).join(", ");
     lines.push(`- **${label}:** ${total} call${total === 1 ? "" : "s"} (${detail})`);
   }
   lines.push(`- **Errors:** ${errorCount}`);
@@ -938,33 +1050,40 @@ function registerHealthTools(server2) {
     async () => {
       const start = Date.now();
       const errors = [];
-      let workspaceId2;
+      let workspaceId;
       try {
-        workspaceId2 = await getWorkspaceId();
+        workspaceId = await getWorkspaceId();
       } catch (e) {
         errors.push(`Workspace resolution failed: ${e.message}`);
       }
       let collections = [];
       try {
-        collections = await mcpQuery("kb.listCollections");
+        collections = await mcpQuery("chain.listCollections");
       } catch (e) {
         errors.push(`Collection fetch failed: ${e.message}`);
       }
       let totalEntries = 0;
       if (collections.length > 0) {
         try {
-          const entries = await mcpQuery("kb.listEntries", {});
+          const entries = await mcpQuery("chain.listEntries", {});
           totalEntries = entries.length;
         } catch (e) {
           errors.push(`Entry count failed: ${e.message}`);
         }
       }
+      let wsCtx = null;
+      try {
+        wsCtx = await getWorkspaceContext();
+      } catch {
+      }
       const durationMs = Date.now() - start;
       const healthy = errors.length === 0;
       const lines = [
         `# ${healthy ? "Healthy" : "Degraded"}`,
         "",
-        `**Workspace:** ${workspaceId2 ?? "unresolved"}`,
+        `**Workspace:** ${workspaceId ?? "unresolved"}`,
+        `**Workspace Slug:** ${wsCtx?.workspaceSlug ?? "unknown"}`,
+        `**Workspace Name:** ${wsCtx?.workspaceName ?? "unknown"}`,
         `**Collections:** ${collections.length}`,
         `**Entries:** ${totalEntries}`,
         `**Latency:** ${durationMs}ms`
@@ -978,6 +1097,213 @@ function registerHealthTools(server2) {
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
   );
+  server2.registerTool(
+    "whoami",
+    {
+      title: "Session Identity",
+      description: "Returns the current workspace and auth context for this MCP session. Use at the start of a session to confirm you're operating on the right workspace before making writes.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const ctx = await getWorkspaceContext();
+      const lines = [
+        `# Session Identity`,
+        "",
+        `**Workspace ID:** ${ctx.workspaceId}`,
+        `**Workspace Slug:** ${ctx.workspaceSlug}`,
+        `**Workspace Name:** ${ctx.workspaceName}`
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "workspace-status",
+    {
+      title: "Workspace Status",
+      description: "The 'Monday morning' tool \u2014 returns workspace readiness score, specific gaps with suggested next actions, and workspace stats (entries, relations, orphans, drafts).\n\nUse this to understand how ready the workspace is, what foundational knowledge is missing, and what to work on next. Great for starting a session or planning knowledge work.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const result = await mcpQuery("chain.workspaceReadiness");
+      const { score, totalChecks, passedChecks, checks, gaps, stats } = result;
+      const scoreBar = "\u2588".repeat(Math.round(score / 10)) + "\u2591".repeat(10 - Math.round(score / 10));
+      const lines = [
+        `# Workspace Readiness: ${score}%`,
+        `${scoreBar} ${passedChecks}/${totalChecks} requirements met`,
+        "",
+        "## Stats",
+        `- **Entries:** ${stats.totalEntries} (${stats.activeCount} active, ${stats.draftCount} draft)`,
+        `- **Relations:** ${stats.totalRelations}`,
+        `- **Collections:** ${stats.collectionCount}`,
+        `- **Orphaned:** ${stats.orphanedCount} committed entries with no relations`,
+        ""
+      ];
+      if (gaps.length > 0) {
+        lines.push("## Gaps (action required)");
+        for (const gap of gaps) {
+          lines.push(`- [ ] **${gap.label}** \u2014 ${gap.description}`);
+          lines.push(`  ${gap.current}/${gap.required} | _${gap.guidance}_`);
+        }
+        lines.push("");
+      }
+      const passed = checks.filter((c) => c.passed);
+      if (passed.length > 0) {
+        lines.push("## Passed");
+        for (const check of passed) {
+          lines.push(`- [x] **${check.label}** (${check.current}/${check.required})`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.registerTool(
+    "orient",
+    {
+      title: "Orient \u2014 Start Here",
+      description: "The single entry point for starting a session. Returns workspace context with a single recommended next action for low-readiness workspaces, or a standup-style briefing for established workspaces.\n\nUse this FIRST. One call to orient replaces 3\u20135 individual tool calls.\n\nCompleting orientation unlocks write tools for the active session.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const errors = [];
+      const agentSessionId = getAgentSessionId();
+      let wsCtx = null;
+      try {
+        wsCtx = await getWorkspaceContext();
+      } catch (e) {
+        errors.push(`Workspace: ${e.message}`);
+      }
+      let priorSessions = [];
+      if (wsCtx) {
+        try {
+          priorSessions = await mcpQuery("agent.recentSessions", { limit: 3 });
+        } catch {
+        }
+      }
+      let constraintEntries = [];
+      try {
+        const [archEntries, ruleEntries, decisionEntries] = await Promise.all([
+          mcpQuery("chain.listEntries", { collectionSlug: "architecture" }),
+          mcpQuery("chain.listEntries", { collectionSlug: "business-rules" }),
+          mcpQuery("chain.listEntries", { collectionSlug: "decisions" })
+        ]);
+        const committed = [
+          ...(archEntries ?? []).filter((e) => e.status === "active" || e.status === "healthy"),
+          ...(ruleEntries ?? []).filter((e) => e.status === "Active" || e.status === "active"),
+          ...(decisionEntries ?? []).filter((e) => e.status === "Decided" || e.status === "active")
+        ];
+        constraintEntries = committed.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0)).slice(0, 8);
+      } catch {
+      }
+      let openTensions = [];
+      try {
+        const tensions = await mcpQuery("chain.listEntries", { collectionSlug: "tensions" });
+        openTensions = (tensions ?? []).filter((e) => e.status === "draft");
+      } catch {
+      }
+      let readiness = null;
+      try {
+        readiness = await mcpQuery("chain.workspaceReadiness");
+      } catch (e) {
+        errors.push(`Readiness: ${e.message}`);
+      }
+      const lines = [];
+      const isLowReadiness = readiness && readiness.score < 50;
+      if (wsCtx) {
+        lines.push(`# ${wsCtx.workspaceName}`);
+        lines.push(`_Workspace \`${wsCtx.workspaceSlug}\` \u2014 Product Brain is healthy._`);
+      } else {
+        lines.push("# Workspace");
+        lines.push("_Could not resolve workspace._");
+      }
+      lines.push("");
+      if (isLowReadiness && wsCtx?.createdAt) {
+        const ageDays = Math.floor((Date.now() - wsCtx.createdAt) / (1e3 * 60 * 60 * 24));
+        if (ageDays >= 30) {
+          lines.push(`Your workspace has been around for ${ageDays} days but is only ${readiness.score}% ready.`);
+          lines.push("Let's close the gaps \u2014 or if the current structure doesn't fit, we can reshape it.");
+          lines.push("");
+        }
+      }
+      if (isLowReadiness) {
+        lines.push(`Readiness: ${readiness.score}% (${readiness.passedChecks}/${readiness.totalChecks}).`);
+        lines.push("");
+        const gaps = readiness.gaps ?? [];
+        if (gaps.length > 0) {
+          const gap = gaps[0];
+          const ctaMap = {
+            "strategy-vision": "Tell me what you're building \u2014 your vision, mission, and north star \u2014 and I'll capture it.",
+            "architecture-layers": "Describe your architecture in a few sentences and I'll capture it.",
+            "glossary-foundation": "What are the key terms your team uses? Tell me a few and I'll add them to the glossary.",
+            "decisions-documented": "What's a recent significant decision your team made? I'll document it with the rationale.",
+            "tensions-tracked": "What's a friction point or pain point you're dealing with? I'll capture it as a tension."
+          };
+          const cta = ctaMap[gap.id] ?? `Tell me about your ${gap.label.toLowerCase()} and I'll capture it.`;
+          lines.push("## Recommended next step");
+          lines.push(`**${gap.label}** (${gap.current}/${gap.required})`);
+          lines.push("");
+          lines.push(cta);
+          lines.push("");
+          lines.push('_Everything stays as a draft until you confirm. Say "commit" or "looks good" to promote to the Chain._');
+          lines.push("");
+          const remainingGaps = gaps.length - 1;
+          if (remainingGaps > 0 || openTensions.length > 0) {
+            lines.push(`_${remainingGaps > 0 ? `${remainingGaps} more gap${remainingGaps === 1 ? "" : "s"}` : ""}${remainingGaps > 0 && openTensions.length > 0 ? " and " : ""}${openTensions.length > 0 ? `${openTensions.length} open tension${openTensions.length === 1 ? "" : "s"}` : ""} \u2014 ask "show full status" for details._`);
+            lines.push("");
+          }
+        }
+      } else if (readiness) {
+        lines.push(`Readiness: ${readiness.score}% (${readiness.passedChecks}/${readiness.totalChecks}).`);
+        lines.push("");
+        const briefingItems = [];
+        if (openTensions.length > 0) {
+          const topTension = openTensions[0];
+          briefingItems.push(`**${openTensions.length} open tension${openTensions.length === 1 ? "" : "s"}** \u2014 top: ${topTension.name}`);
+        }
+        if (priorSessions.length > 0) {
+          const last = priorSessions[0];
+          const date = new Date(last.startedAt).toISOString().split("T")[0];
+          const created = Array.isArray(last.entriesCreated) ? last.entriesCreated.length : last.entriesCreated ?? 0;
+          const modified = Array.isArray(last.entriesModified) ? last.entriesModified.length : last.entriesModified ?? 0;
+          briefingItems.push(`**Last session** (${date}): ${created} created, ${modified} modified`);
+        }
+        if (readiness.gaps?.length > 0) {
+          briefingItems.push(`**${readiness.gaps.length} gap${readiness.gaps.length === 1 ? "" : "s"}** remaining`);
+        }
+        if (constraintEntries.length > 0) {
+          briefingItems.push(`**${constraintEntries.length} active constraint${constraintEntries.length === 1 ? "" : "s"}** (architecture, rules, decisions)`);
+        }
+        if (briefingItems.length > 0) {
+          lines.push("## Briefing");
+          for (const item of briefingItems) {
+            lines.push(`- ${item}`);
+          }
+          lines.push("");
+        }
+        lines.push("What would you like to work on?");
+        lines.push("");
+      }
+      if (errors.length > 0) {
+        lines.push("## Errors");
+        for (const err of errors) lines.push(`- ${err}`);
+        lines.push("");
+      }
+      if (agentSessionId) {
+        try {
+          await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+          setSessionOriented(true);
+          lines.push("---");
+          lines.push(`Orientation complete. Session ${agentSessionId}. Write tools available.`);
+        } catch {
+          lines.push("---");
+          lines.push("_Warning: Could not mark session as oriented. Write tools may be restricted._");
+        }
+      } else {
+        lines.push("---");
+        lines.push("_No active agent session. Call `agent-start` to begin a tracked session._");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
   server2.registerTool(
     "mcp-audit",
     {
@@ -989,13 +1315,13 @@ function registerHealthTools(server2) {
       annotations: { readOnlyHint: true }
     },
     async ({ limit }) => {
-      const log2 = getAuditLog();
-      const recent = log2.slice(-limit);
+      const log = getAuditLog();
+      const recent = log.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)
+      const summary = buildSessionSummary(log);
+      const logLines = [`# Audit Log (last ${recent.length} of ${log.length} total)
 `];
       for (const entry of recent) {
         const icon = entry.status === "ok" ? "\u2713" : "\u2717";
@@ -1188,7 +1514,7 @@ function registerVerifyTools(server2) {
         data: `Verifying "${collection}" against ${schema.size} schema tables at ${projectRoot}`,
         logger: "product-os"
       });
-      const scopedEntries = await mcpQuery("kb.listEntries", { collectionSlug: collection });
+      const scopedEntries = await mcpQuery("chain.listEntries", { collectionSlug: collection });
       if (scopedEntries.length === 0) {
         return {
           content: [{ type: "text", text: `No entries found in \`${collection}\`. Nothing to verify.` }]
@@ -1196,7 +1522,7 @@ function registerVerifyTools(server2) {
       }
       let allEntryIds;
       try {
-        const allEntries = await mcpQuery("kb.listEntries", {});
+        const allEntries = await mcpQuery("chain.listEntries", {});
         allEntryIds = new Set(allEntries.map((e) => e.entryId).filter(Boolean));
       } catch {
         allEntryIds = new Set(scopedEntries.map((e) => e.entryId).filter(Boolean));
@@ -1261,7 +1587,7 @@ function registerVerifyTools(server2) {
           const updated = (entry.data?.codeMapping ?? []).map(
             (cm) => cm.status === "aligned" && driftedFields.has(cm.field) ? { ...cm, status: "drifted" } : cm
           );
-          await mcpMutation("kb.updateEntry", {
+          await mcpMutation("chain.updateEntry", {
             entryId: entry.entryId,
             data: { codeMapping: updated }
           });
@@ -1283,626 +1609,10 @@ function registerVerifyTools(server2) {
   );
 }
 
-// src/tools/smart-capture.ts
-import { z as z5 } from "zod";
-var AREA_KEYWORDS = {
-  "Architecture": ["convex", "schema", "database", "migration", "api", "backend", "infrastructure", "scaling", "performance"],
-  "Chain": ["knowledge", "glossary", "entry", "collection", "terminology", "drift", "graph", "chain", "commit"],
-  "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 add more connections."
-  },
-  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",
-          "Chain": "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."
-      }
-    ]
-  }],
-  ["features", {
-    idPrefix: "FEAT",
-    governedDraft: false,
-    descriptionField: "description",
-    defaults: [],
-    recommendedRelationTypes: ["belongs_to", "depends_on", "surfaces_tension_in", "related_to"],
-    qualityChecks: [
-      COMMON_CHECKS.clearName,
-      COMMON_CHECKS.hasDescription,
-      COMMON_CHECKS.hasRelations,
-      {
-        id: "has-owner",
-        label: "Owner assigned",
-        check: (ctx) => !!ctx.data.owner && ctx.data.owner !== "",
-        suggestion: () => "Assign an owner team or product area."
-      },
-      {
-        id: "has-rationale",
-        label: "Rationale documented",
-        check: (ctx) => !!ctx.data.rationale && String(ctx.data.rationale).length > 20,
-        suggestion: () => "Explain why this feature matters \u2014 what problem does it solve?"
-      }
-    ]
-  }]
-]);
-var FALLBACK_PROFILE = {
-  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 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(
-    "capture",
-    {
-      title: "Capture",
-      description: "The single tool for creating knowledge entries. Creates an entry, auto-links related entries, and returns a quality scorecard \u2014 all in one call. 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, features.\nAll other collections use sensible defaults.\n\nAlways creates as 'draft' for governed collections. Use `update-entry` for post-creation adjustments.",
-      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: "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/tools/architecture.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
 import { resolve as resolve2, relative, dirname, normalize } from "path";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var COLLECTION_SLUG = "architecture";
 var COLLECTION_FIELDS = [
   { key: "archType", label: "Architecture Type", type: "select", required: true, options: ["template", "layer", "node", "flow"], searchable: true },
@@ -1920,9 +1630,9 @@ var COLLECTION_FIELDS = [
   { key: "dependsOn", label: "Allowed Dependencies (layers this can import from)", type: "text" }
 ];
 async function ensureCollection() {
-  const collections = await mcpQuery("kb.listCollections");
+  const collections = await mcpQuery("chain.listCollections");
   if (collections.some((c) => c.slug === COLLECTION_SLUG)) return;
-  await mcpMutation("kb.createCollection", {
+  await mcpMutation("chain.createCollection", {
     slug: COLLECTION_SLUG,
     name: "Architecture",
     icon: "\u{1F3D7}\uFE0F",
@@ -1931,7 +1641,7 @@ async function ensureCollection() {
   });
 }
 async function listArchEntries() {
-  return mcpQuery("kb.listEntries", { collectionSlug: COLLECTION_SLUG });
+  return mcpQuery("chain.listEntries", { collectionSlug: COLLECTION_SLUG });
 }
 function byTag(entries, archType) {
   return entries.filter((e) => e.tags?.includes(`archType:${archType}`) || e.data?.archType === archType).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
@@ -2056,10 +1766,10 @@ function registerArchitectureTools(server2) {
       title: "Architecture",
       description: "Explore the system architecture \u2014 show the full map, explore a specific layer, or visualize a data flow.\n\nActions:\n- `show`: Render the layered architecture map (Auth \u2192 Infra \u2192 Core \u2192 Features \u2192 Integration)\n- `explore`: Drill into a layer to see nodes, ownership, file paths\n- `flow`: Visualize a data flow path between nodes",
       inputSchema: {
-        action: z6.enum(["show", "explore", "flow"]).describe("Action: show full map, explore a layer, or visualize a flow"),
-        template: z6.string().optional().describe("Template entry ID to filter by (for show)"),
-        layer: z6.string().optional().describe("Layer name or entry ID (for explore), e.g. 'Core' or 'ARCH-layer-core'"),
-        flow: z6.string().optional().describe("Flow name or entry ID (for flow), e.g. 'Smart Capture Flow'")
+        action: z5.enum(["show", "explore", "flow"]).describe("Action: show full map, explore a layer, or visualize a flow"),
+        template: z5.string().optional().describe("Template entry ID to filter by (for show)"),
+        layer: z5.string().optional().describe("Layer name or entry ID (for explore), e.g. 'Core' or 'ARCH-layer-core'"),
+        flow: z5.string().optional().describe("Flow name or entry ID (for flow), e.g. 'Smart Capture Flow'")
       },
       annotations: { readOnlyHint: true }
     },
@@ -2178,7 +1888,7 @@ ${nodeDetail}${flowLines}`
       title: "Architecture Admin",
       description: "Architecture maintenance \u2014 seed the default architecture data or run a dependency health check.\n\nActions:\n- `seed`: Populate the architecture collection with the default Product OS map. Safe to re-run.\n- `check`: Scan the codebase for dependency direction violations against layer rules.",
       inputSchema: {
-        action: z6.enum(["seed", "check"]).describe("Action: seed default architecture data, or check dependency health")
+        action: z5.enum(["seed", "check"]).describe("Action: seed default architecture data, or check dependency health")
       }
     },
     async ({ action }) => {
@@ -2205,14 +1915,14 @@ ${nodeDetail}${flowLines}`
             );
             if (hasChanges) {
               const mergedData = { ...existingData, ...seedData };
-              await mcpMutation("kb.updateEntry", { entryId: seed.entryId, data: mergedData });
+              await mcpMutation("chain.updateEntry", { entryId: seed.entryId, data: mergedData });
               updated++;
             } else {
               unchanged++;
             }
             continue;
           }
-          await mcpMutation("kb.createEntry", {
+          await mcpMutation("chain.createEntry", {
             collectionSlug: COLLECTION_SLUG,
             entryId: seed.entryId,
             name: seed.name,
@@ -2471,7 +2181,7 @@ function formatScanReport(result) {
 }
 
 // src/tools/workflows.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // src/workflows/definitions.ts
 var RETRO_WORKFLOW = {
@@ -2700,16 +2410,16 @@ ${cards}`
       title: "Workflow Checkpoint",
       description: "Record the output of a workflow round. Captures the round's data to the Chain as a structured entry. Use this during Facilitator Mode after completing each round to persist progress \u2014 so if the conversation is interrupted, work is not lost.\n\nAt workflow completion, this tool can also generate the final summary entry.",
       inputSchema: {
-        workflowId: z7.string().describe("Workflow ID (e.g., 'retro')"),
-        roundId: z7.string().describe("Round ID (e.g., 'what-went-well')"),
-        output: z7.string().describe("The round's output \u2014 synthesized by the facilitator from the conversation"),
-        isFinal: z7.boolean().optional().describe(
+        workflowId: z6.string().describe("Workflow ID (e.g., 'retro')"),
+        roundId: z6.string().describe("Round ID (e.g., 'what-went-well')"),
+        output: z6.string().describe("The round's output \u2014 synthesized by the facilitator from the conversation"),
+        isFinal: z6.boolean().optional().describe(
           "If true, this is the final checkpoint and triggers the summary chain entry creation"
         ),
-        summaryName: z7.string().optional().describe(
+        summaryName: z6.string().optional().describe(
           "Name for the final chain entry (required when isFinal=true)"
         ),
-        summaryDescription: z7.string().optional().describe(
+        summaryDescription: z6.string().optional().describe(
           "Full description/rationale for the final chain entry (required when isFinal=true)"
         )
       },
@@ -2745,7 +2455,7 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
       ];
       if (isFinal && summaryName && summaryDescription) {
         try {
-          const entryId = await mcpMutation("kb.createEntry", {
+          const entryId = await mcpMutation("chain.createEntry", {
             collectionSlug: wf.kbOutputCollection,
             name: summaryName,
             status: "draft",
@@ -2802,8 +2512,139 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
   );
 }
 
+// src/tools/session.ts
+function registerSessionTools(server2) {
+  server2.registerTool(
+    "agent-start",
+    {
+      title: "Start Agent Session",
+      description: "Start an agent session. Creates a tracked session for this workspace with full attribution. If a session is already active, it gets superseded (graceful handover). Write tools are available after calling orient.",
+      annotations: { readOnlyHint: false }
+    },
+    async () => {
+      try {
+        const result = await startAgentSession();
+        const lines = [];
+        if (result.superseded) {
+          lines.push(
+            `Previous session superseded. Session ${result.superseded.previousSessionId} (started ${result.superseded.startedAt}, initiated by ${result.superseded.initiatedBy}) was closed.`,
+            ""
+          );
+        }
+        lines.push(
+          `Session ${result.sessionId} active. Initiated by ${result.initiatedBy}. Workspace ${result.workspaceName}. Scope: ${result.toolsScope}. Write tools available after orient.`
+        );
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Failed to start agent session: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "agent-close",
+    {
+      title: "Close Agent Session",
+      description: "Close the current agent session. Records structured session data (entries created, modified, relations, gate results). After this, write tools are blocked even if the MCP connection stays open.",
+      annotations: { readOnlyHint: false }
+    },
+    async () => {
+      try {
+        const sessionId = getAgentSessionId();
+        if (!sessionId) {
+          return {
+            content: [{ type: "text", text: "No active agent session to close." }]
+          };
+        }
+        const session = await mcpCall("agent.getSession", {
+          sessionId
+        });
+        await closeAgentSession();
+        const lines = [
+          `Session ${sessionId} closed.`,
+          ""
+        ];
+        if (session) {
+          const created = session.entriesCreated?.length ?? 0;
+          const modified = session.entriesModified?.length ?? 0;
+          const relations = session.relationsCreated ?? 0;
+          const gates = session.gateFailures ?? 0;
+          const warnings = session.contradictionWarnings ?? 0;
+          lines.push(
+            `| Metric | Count |`,
+            `|--------|-------|`,
+            `| Entries created | ${created} |`,
+            `| Entries modified | ${modified} |`,
+            `| Relations created | ${relations} |`,
+            `| Gate failures | ${gates} |`,
+            `| Contradiction warnings | ${warnings} |`
+          );
+        }
+        lines.push("", "Write tools are now blocked. Session data saved for future orientation.");
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Failed to close agent session: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "agent-status",
+    {
+      title: "Agent Session Status",
+      description: "Check the current agent session status \u2014 whether a session is active, whether orientation is complete, and session activity so far.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      try {
+        const sessionId = getAgentSessionId();
+        if (!sessionId) {
+          return {
+            content: [{ type: "text", text: "No active agent session. Call `agent-start` to begin." }]
+          };
+        }
+        const session = await mcpCall("agent.getSession", {
+          sessionId
+        });
+        if (!session) {
+          return {
+            content: [{ type: "text", text: "Session ID cached but not found in Convex. Call `agent-start` to create a new session." }]
+          };
+        }
+        const oriented = isSessionOriented();
+        const created = session.entriesCreated?.length ?? 0;
+        const modified = session.entriesModified?.length ?? 0;
+        const lines = [
+          `Session ${sessionId} ${session.status}.`,
+          `Initiated by ${session.initiatedBy}.`,
+          `Scope: ${session.toolsScope}.`,
+          `Oriented: ${oriented ? "yes" : "no"}.`,
+          "",
+          `| Metric | Value |`,
+          `|--------|-------|`,
+          `| Entries created | ${created} |`,
+          `| Entries modified | ${modified} |`,
+          `| Relations created | ${session.relationsCreated ?? 0} |`,
+          `| Started | ${new Date(session.startedAt).toISOString()} |`,
+          `| Expires | ${new Date(session.expiresAt).toISOString()} |`
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Failed to get session status: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/tools/gitchain.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 function linkSummary(links) {
   return Object.entries(links).map(([id, content]) => {
     const filled = typeof content === "string" && content.length > 0;
@@ -2818,15 +2659,15 @@ function registerGitChainTools(server2) {
       title: "Chain",
       description: "Manage processes \u2014 create, get, list, or edit process links. Processes are versioned knowledge artifacts that follow a process template (e.g. Strategy Coherence: Problem \u2192 Insight \u2192 Choice \u2192 Action \u2192 Outcome).",
       inputSchema: {
-        action: z8.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
-        chainEntryId: z8.string().optional().describe("Chain entry ID (required for get/edit)"),
-        title: z8.string().optional().describe("Process title (required for create)"),
-        chainTypeId: z8.string().optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
-        description: z8.string().optional().describe("Description (for create)"),
-        linkId: z8.string().optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
-        content: z8.string().optional().describe("New content for the link (for edit action)"),
-        status: z8.string().optional().describe("Filter by status for list: 'draft' or 'active'"),
-        author: z8.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+        action: z7.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
+        chainEntryId: z7.string().optional().describe("Chain entry ID (required for get/edit)"),
+        title: z7.string().optional().describe("Process title (required for create)"),
+        chainTypeId: z7.string().optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
+        description: z7.string().optional().describe("Description (for create)"),
+        linkId: z7.string().optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
+        content: z7.string().optional().describe("New content for the link (for edit action)"),
+        status: z7.string().optional().describe("Filter by status for list: 'draft' or 'active'"),
+        author: z7.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
       }
     },
     async ({ action, chainEntryId, title, chainTypeId, description, linkId, content, status, author }) => {
@@ -2923,13 +2764,13 @@ Use \`chain action=get\` to see the full chain with updated scores.`
       title: "Chain Version",
       description: "Manage process versions \u2014 commit snapshots, list commits, view history, diff versions, or revert. Commits record all link content, compute coherence scores, and track changes.",
       inputSchema: {
-        action: z8.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
-        chainEntryId: z8.string().describe("The chain's entry ID"),
-        commitMessage: z8.string().optional().describe("Commit message (required for commit). Convention: type(link): description"),
-        versionA: z8.number().optional().describe("Earlier version for diff"),
-        versionB: z8.number().optional().describe("Later version for diff"),
-        toVersion: z8.number().optional().describe("Version number to revert to"),
-        author: z8.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+        action: z7.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
+        chainEntryId: z7.string().describe("The chain's entry ID"),
+        commitMessage: z7.string().optional().describe("Commit message (required for commit). Convention: type(link): description"),
+        versionA: z7.number().optional().describe("Earlier version for diff"),
+        versionB: z7.number().optional().describe("Later version for diff"),
+        toVersion: z7.number().optional().describe("Version number to revert to"),
+        author: z7.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
       },
       annotations: { readOnlyHint: false }
     },
@@ -3037,11 +2878,11 @@ ${formatted}` }] };
       title: "Chain Branch",
       description: "Manage process branches \u2014 create a branch for isolated editing, list branches, merge a branch back into main, or check for conflicts.",
       inputSchema: {
-        action: z8.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
-        chainEntryId: z8.string().describe("The chain's entry ID"),
-        branchName: z8.string().optional().describe("Branch name (required for merge/conflicts, optional for create)"),
-        strategy: z8.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
-        author: z8.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+        action: z7.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
+        chainEntryId: z7.string().describe("The chain's entry ID"),
+        branchName: z7.string().optional().describe("Branch name (required for merge/conflicts, optional for create)"),
+        strategy: z7.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
+        author: z7.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
       }
     },
     async ({ action, chainEntryId, branchName, strategy, author }) => {
@@ -3125,14 +2966,14 @@ Resolve conflicts before merging.`
       title: "Chain Review",
       description: "Review process quality \u2014 run the coherence gate or manage comments on process versions. The gate checks: coherence score >= 70%, all links filled, commit message convention.",
       inputSchema: {
-        action: z8.enum(["gate", "comment", "resolve-comment", "list-comments"]).describe("Action: run coherence gate, add a comment, resolve a comment, or list comments"),
-        chainEntryId: z8.string().describe("The chain's entry ID"),
-        commitMessage: z8.string().optional().describe("Commit message to lint (for gate action)"),
-        versionNumber: z8.number().optional().describe("Version to comment on or list comments for"),
-        linkId: z8.string().optional().describe("Link this comment targets (optional for comment)"),
-        body: z8.string().optional().describe("Comment text (required for comment action)"),
-        commentId: z8.string().optional().describe("Comment ID (required for resolve-comment)"),
-        author: z8.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+        action: z7.enum(["gate", "comment", "resolve-comment", "list-comments"]).describe("Action: run coherence gate, add a comment, resolve a comment, or list comments"),
+        chainEntryId: z7.string().describe("The chain's entry ID"),
+        commitMessage: z7.string().optional().describe("Commit message to lint (for gate action)"),
+        versionNumber: z7.number().optional().describe("Version to comment on or list comments for"),
+        linkId: z7.string().optional().describe("Link this comment targets (optional for comment)"),
+        body: z7.string().optional().describe("Comment text (required for comment action)"),
+        commentId: z7.string().optional().describe("Comment ID (required for resolve-comment)"),
+        author: z7.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
       },
       annotations: { readOnlyHint: false }
     },
@@ -3211,40 +3052,799 @@ ${formatted}`
   );
 }
 
-// src/resources/index.ts
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-function formatEntryMarkdown(entry) {
-  const id = entry.entryId ? `${entry.entryId}: ` : "";
-  const lines = [`## ${id}${entry.name} [${entry.status}]`];
-  if (entry.data && typeof entry.data === "object") {
-    for (const [key, val] of Object.entries(entry.data)) {
-      if (val && key !== "rawData") {
-        lines.push(`**${key}**: ${typeof val === "string" ? val : JSON.stringify(val)}`);
-      }
-    }
-  }
-  return lines.join("\n");
+// src/tools/maps.ts
+import { z as z8 } from "zod";
+function slotSummary(slots) {
+  return Object.entries(slots).map(([id, refs]) => {
+    if (!refs || refs.length === 0) return `  - **${id}**: (empty)`;
+    const items = refs.map((r) => {
+      const name = r.ingredientName ?? r.label ?? r.entryId;
+      const version = r.pinnedVersion ? ` v${r.pinnedVersion}` : "";
+      const status = r.ingredientStatus ? ` [${r.ingredientStatus}]` : "";
+      return `${name}${version}${status}`;
+    }).join(", ");
+    return `  - **${id}**: ${items}`;
+  }).join("\n");
 }
-function buildOrientationMarkdown(collections, trackingEvents, standards, businessRules) {
-  const sections = ["# Product Brain \u2014 Orientation"];
-  sections.push(
-    "## Architecture\n```\nCursor (stdio) \u2192 MCP Server (mcp-server/src/index.ts)\n  \u2192 POST /api/mcp with Bearer token\n  \u2192 Convex HTTP Action (convex/http.ts)\n  \u2192 internalQuery / internalMutation (convex/mcpKnowledge.ts)\n  \u2192 Convex DB (workspace-scoped)\n```\nSecurity: API key auth on every request, workspace-scoped data, internal functions blocked from external clients.\nKey files: `packages/mcp-server/src/client.ts` (HTTP client + audit), `convex/schema.ts` (schema)."
-  );
-  if (collections) {
-    const collList = collections.map((c) => {
-      const prefix = c.icon ? `${c.icon} ` : "";
-      return `- ${prefix}**${c.name}** (\`${c.slug}\`) \u2014 ${c.description || "no description"}`;
-    }).join("\n");
-    sections.push(
-      `## Data Model (${collections.length} collections)
-Unified entries model: collections define field schemas, entries hold data in a flexible \`data\` field.
-Tags for filtering (e.g. \`severity:high\`), relations via \`entryRelations\`, history via \`entryHistory\`, labels via \`labels\` + \`entryLabels\`.
-
-` + collList + "\n\nUse `list-collections` for field schemas, `get-entry` for full records."
-    );
-  } else {
-    sections.push(
-      "## Data Model\nCould not load collections \u2014 use `list-collections` to browse manually."
+function registerMapTools(server2) {
+  server2.registerTool(
+    "map",
+    {
+      title: "Map",
+      description: "Manage composed framework maps \u2014 create, get, or list. Maps assemble ingredient entries into framework slots (e.g. Lean Canvas). Use map-slot to add/remove ingredients, map-version to commit and view history.",
+      inputSchema: {
+        action: z8.enum(["create", "get", "list"]).describe("Action: create a map, get map details, or list all maps"),
+        mapEntryId: z8.string().optional().describe("Map entry ID (for get)"),
+        title: z8.string().optional().describe("Map title (for create)"),
+        templateId: z8.string().optional().default("lean-canvas").describe("Template slug for create: 'lean-canvas' or any composed template"),
+        description: z8.string().optional().describe("Description (for create)"),
+        slotIds: z8.array(z8.string()).optional().describe("Slot IDs to initialize (for create; auto-populated from template if omitted)"),
+        status: z8.string().optional().describe("Filter by status for list")
+      }
+    },
+    async ({ action, mapEntryId, title, templateId, description, slotIds, status }) => {
+      if (action === "create") {
+        if (!title) {
+          return {
+            content: [
+              { type: "text", text: "A `title` is required to create a map." }
+            ]
+          };
+        }
+        const result = await mcpMutation(
+          "maps.createMap",
+          { title, templateId, description, slotIds }
+        );
+        const wsCtx = await getWorkspaceContext();
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Map Created
+
+- **Entry ID:** \`${result.entryId}\`
+- **Title:** ${title}
+- **Template:** ${templateId}
+- **Status:** draft
+- **Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})
+
+Use \`map-slot action=add mapEntryId="${result.entryId}" slotId="problem" ingredientEntryId="..."\` to start filling slots.`
+            }
+          ]
+        };
+      }
+      if (action === "get") {
+        if (!mapEntryId) {
+          return {
+            content: [{ type: "text", text: "A `mapEntryId` is required." }]
+          };
+        }
+        const map = await mcpQuery("maps.getMap", { mapEntryId });
+        if (!map) {
+          return {
+            content: [{ type: "text", text: `Map "${mapEntryId}" not found.` }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# ${map.name}
+
+- **Entry ID:** \`${map.entryId}\`
+- **Template:** ${map.templateName}
+- **Status:** ${map.status}
+- **Version:** ${map.currentVersion}
+- **Completion:** ${map.completionScore}% (${map.filledSlots}/${map.totalSlots} slots)
+
+## Slots
+
+` + slotSummary(map.slots)
+            }
+          ]
+        };
+      }
+      if (action === "list") {
+        const maps = await mcpQuery("maps.listMaps", {
+          templateId: templateId !== "lean-canvas" ? templateId : void 0,
+          status
+        });
+        if (!maps || maps.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: 'No maps found. Create one with `map action=create title="My Canvas"`.'
+              }
+            ]
+          };
+        }
+        const lines = maps.map(
+          (m) => `- **${m.name}** (\`${m.entryId}\`) \u2014 ${m.templateId}, ${m.completionScore}% complete, v${m.currentVersion}`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Maps (${maps.length})
+
+${lines.join("\n")}`
+            }
+          ]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Unknown action: ${action}` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "map-slot",
+    {
+      title: "Map Slot",
+      description: "Add, remove, or replace ingredient references in a map's slots. Ingredients are entries from any collection that fill a framework position.",
+      inputSchema: {
+        action: z8.enum(["add", "remove", "replace", "list"]).describe("Action: add/remove/replace an ingredient in a slot, or list slot contents"),
+        mapEntryId: z8.string().describe("Map entry ID"),
+        slotId: z8.string().optional().describe("Slot ID (e.g. 'problem', 'customer-segments')"),
+        ingredientEntryId: z8.string().optional().describe("Ingredient entry ID to add/remove"),
+        newIngredientEntryId: z8.string().optional().describe("New ingredient entry ID (for replace)"),
+        label: z8.string().optional().describe("Display label override"),
+        author: z8.string().optional().describe("Who is performing the action")
+      }
+    },
+    async ({
+      action,
+      mapEntryId,
+      slotId,
+      ingredientEntryId,
+      newIngredientEntryId,
+      label,
+      author
+    }) => {
+      if (action === "list") {
+        const map = await mcpQuery("maps.getMap", { mapEntryId });
+        if (!map) {
+          return {
+            content: [{ type: "text", text: `Map "${mapEntryId}" not found.` }]
+          };
+        }
+        if (slotId && map.slots[slotId]) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `# Slot: ${slotId}
+
+` + (map.slots[slotId].length === 0 ? "(empty)" : map.slots[slotId].map(
+                  (r) => `- **${r.ingredientName ?? r.entryId}** (\`${r.entryId}\`)${r.pinnedVersion ? ` v${r.pinnedVersion}` : ""}`
+                ).join("\n"))
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            { type: "text", text: `## All Slots
+
+${slotSummary(map.slots)}` }
+          ]
+        };
+      }
+      if (action === "add") {
+        if (!slotId || !ingredientEntryId) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Both `slotId` and `ingredientEntryId` are required for add."
+              }
+            ]
+          };
+        }
+        await mcpMutation("maps.addToSlot", {
+          mapEntryId,
+          slotId,
+          ingredientEntryId,
+          label,
+          author
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Added \`${ingredientEntryId}\` to slot "${slotId}" on map \`${mapEntryId}\`.`
+            }
+          ]
+        };
+      }
+      if (action === "remove") {
+        if (!slotId || !ingredientEntryId) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Both `slotId` and `ingredientEntryId` are required for remove."
+              }
+            ]
+          };
+        }
+        await mcpMutation("maps.removeFromSlot", {
+          mapEntryId,
+          slotId,
+          ingredientEntryId,
+          author
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Removed \`${ingredientEntryId}\` from slot "${slotId}" on map \`${mapEntryId}\`.`
+            }
+          ]
+        };
+      }
+      if (action === "replace") {
+        if (!slotId || !ingredientEntryId || !newIngredientEntryId) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "`slotId`, `ingredientEntryId`, and `newIngredientEntryId` are required for replace."
+              }
+            ]
+          };
+        }
+        await mcpMutation("maps.replaceInSlot", {
+          mapEntryId,
+          slotId,
+          oldIngredientEntryId: ingredientEntryId,
+          newIngredientEntryId,
+          label,
+          author
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Replaced \`${ingredientEntryId}\` with \`${newIngredientEntryId}\` in slot "${slotId}".`
+            }
+          ]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Unknown action: ${action}` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "map-version",
+    {
+      title: "Map Version",
+      description: "Commit a map (pins ingredient versions), list commit history, or view a specific commit.",
+      inputSchema: {
+        action: z8.enum(["commit", "list", "history"]).describe("Action: commit the map, list commits, or view commit history"),
+        mapEntryId: z8.string().describe("Map entry ID"),
+        commitMessage: z8.string().optional().describe("Commit message (for commit action)"),
+        author: z8.string().optional().describe("Who is committing")
+      }
+    },
+    async ({ action, mapEntryId, commitMessage, author }) => {
+      if (action === "commit") {
+        const result = await mcpMutation("maps.commitMap", {
+          mapEntryId,
+          commitMessage: commitMessage ?? "Map committed",
+          author
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Map Committed
+
+- **Version:** ${result.version}
+- **Completion:** ${result.completionScore}%
+- **Slots modified:** ${result.slotsModified.length > 0 ? result.slotsModified.join(", ") : "(none)"}
+
+All ingredient references have been pinned at their current versions.`
+            }
+          ]
+        };
+      }
+      if (action === "list" || action === "history") {
+        const commits = await mcpQuery("maps.listMapCommits", {
+          mapEntryId
+        });
+        if (!commits || commits.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No commits yet for map \`${mapEntryId}\`. Use \`map-version action=commit\` to create the first snapshot.`
+              }
+            ]
+          };
+        }
+        const lines = commits.map(
+          (c) => `- **v${c.version}** (${new Date(c.createdAt).toLocaleDateString()}) \u2014 ${c.commitMessage ?? "(no message)"} \u2014 by ${c.author}` + (c.slotsModified.length > 0 ? `
+  Slots changed: ${c.slotsModified.join(", ")}` : "")
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Map History: \`${mapEntryId}\` (${commits.length} commits)
+
+${lines.join("\n")}`
+            }
+          ]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Unknown action: ${action}` }]
+      };
+    }
+  );
+  server2.registerTool(
+    "map-suggest",
+    {
+      title: "Map Suggest",
+      description: "Given a map with empty slots, search the Chain for ingredients that could fill them. Uses keyword search and collection matching based on the template's suggested collections.",
+      inputSchema: {
+        mapEntryId: z8.string().describe("Map entry ID to suggest ingredients for"),
+        slotId: z8.string().optional().describe("Specific slot to find ingredients for (or all empty slots)"),
+        query: z8.string().optional().describe("Optional search query to narrow ingredient suggestions")
+      }
+    },
+    async ({ mapEntryId, slotId, query }) => {
+      const map = await mcpQuery("maps.getMap", { mapEntryId });
+      if (!map) {
+        return {
+          content: [{ type: "text", text: `Map "${mapEntryId}" not found.` }]
+        };
+      }
+      const emptySlots = slotId ? [slotId].filter((id) => (map.slots[id]?.length ?? 0) === 0) : Object.entries(map.slots).filter(([, refs]) => refs.length === 0).map(([id]) => id);
+      if (emptySlots.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: slotId ? `Slot "${slotId}" already has ingredients.` : "All slots have ingredients. Nothing to suggest."
+            }
+          ]
+        };
+      }
+      const slotDefs = map.slotDefs ?? [];
+      const suggestions = [];
+      for (const sid of emptySlots) {
+        const def = slotDefs.find((s) => s.id === sid);
+        const searchQuery = query ?? def?.label ?? sid;
+        const results = await mcpQuery("knowledge.search", {
+          query: searchQuery,
+          limit: 5
+        });
+        if (results && results.length > 0) {
+          const items = results.map(
+            (r) => `  - **${r.name}** (\`${r.entryId}\`, ${r.collectionName ?? "unknown"}) \u2014 ${r.status}`
+          );
+          suggestions.push(
+            `### ${def?.label ?? sid}
+${def?.description ?? ""}
+
+${items.join("\n")}`
+          );
+        } else {
+          suggestions.push(
+            `### ${def?.label ?? sid}
+_No matching entries found. Create ingredients first._`
+          );
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# Ingredient Suggestions for "${map.name}"
+
+` + suggestions.join("\n\n") + `
+
+Use \`map-slot action=add mapEntryId="${mapEntryId}" slotId="..." ingredientEntryId="..."\` to add ingredients.`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/start.ts
+import { z as z9 } from "zod";
+
+// src/presets/collections.ts
+var COLLECTION_PRESETS = [
+  {
+    id: "software-product",
+    name: "Software Product",
+    description: "For teams building software products \u2014 glossary, features, architecture, tech debt, and API endpoints",
+    collections: [
+      { slug: "glossary", name: "Glossary", description: "Canonical terminology for the product domain", fields: [{ key: "canonical", label: "Canonical", type: "string", required: true, searchable: true }, { key: "category", label: "Category", type: "select", options: ["Platform & Architecture", "Knowledge Management", "AI & Developer Tools", "Governance & Process"] }, { key: "confusedWith", label: "Confused With", type: "array" }] },
+      { slug: "features", name: "Features", description: "Product features and capabilities", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "scope", label: "Scope", type: "string" }, { key: "area", label: "Area", type: "string" }, { key: "status", label: "Status", type: "select", options: ["proposed", "in-progress", "shipped", "deprecated"] }] },
+      { slug: "architecture", name: "Architecture", description: "System architecture layers and components", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "layer", label: "Layer", type: "string" }, { key: "dependencies", label: "Dependencies", type: "array" }] },
+      { slug: "tech-debt", name: "Tech Debt", description: "Technical debt items to track and address", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "severity", label: "Severity", type: "select", options: ["low", "medium", "high", "critical"] }, { key: "area", label: "Area", type: "string" }, { key: "effort", label: "Effort", type: "select", options: ["small", "medium", "large"] }] },
+      { slug: "api-endpoints", name: "API Endpoints", description: "REST/GraphQL endpoints and their contracts", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "method", label: "Method", type: "select", options: ["GET", "POST", "PUT", "PATCH", "DELETE"] }, { key: "path", label: "Path", type: "string" }, { key: "auth", label: "Auth Required", type: "select", options: ["none", "api-key", "bearer", "session"] }] },
+      { slug: "decisions", name: "Decisions", description: "Significant decisions with rationale and context", fields: [{ key: "rationale", label: "Rationale", type: "string", required: true, searchable: true }, { key: "date", label: "Date", type: "string" }, { key: "decidedBy", label: "Decided By", type: "string" }, { key: "alternatives", label: "Alternatives", type: "string" }] },
+      { slug: "tensions", name: "Tensions", description: "Friction points, pain points, and unmet needs", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "priority", label: "Priority", type: "select", options: ["low", "medium", "high", "critical"] }, { key: "severity", label: "Severity", type: "select", options: ["low", "medium", "high", "critical"] }] }
+    ]
+  },
+  {
+    id: "content-business",
+    name: "Content Business",
+    description: "For content creators, publishers, and media companies \u2014 topics, audience segments, content calendar, and brand voice",
+    collections: [
+      { slug: "glossary", name: "Glossary", description: "Industry terminology and brand language", fields: [{ key: "canonical", label: "Canonical", type: "string", required: true, searchable: true }, { key: "category", label: "Category", type: "string" }] },
+      { slug: "topics", name: "Topics", description: "Content topics and themes", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "pillar", label: "Content Pillar", type: "string" }, { key: "stage", label: "Stage", type: "select", options: ["idea", "researching", "drafting", "published", "evergreen"] }] },
+      { slug: "audience-segments", name: "Audience Segments", description: "Target reader/viewer personas", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "painPoints", label: "Pain Points", type: "string" }, { key: "channels", label: "Channels", type: "array" }] },
+      { slug: "brand-voice", name: "Brand Voice", description: "Tone, style, and voice guidelines", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "doThis", label: "Do This", type: "string" }, { key: "notThis", label: "Not This", type: "string" }] },
+      { slug: "decisions", name: "Decisions", description: "Editorial and strategic decisions", fields: [{ key: "rationale", label: "Rationale", type: "string", required: true, searchable: true }, { key: "date", label: "Date", type: "string" }, { key: "decidedBy", label: "Decided By", type: "string" }] },
+      { slug: "tensions", name: "Tensions", description: "Content gaps, audience friction, and unmet needs", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "priority", label: "Priority", type: "select", options: ["low", "medium", "high", "critical"] }] }
+    ]
+  },
+  {
+    id: "agency",
+    name: "Agency",
+    description: "For agencies managing multiple clients \u2014 client profiles, project scopes, deliverables, and processes",
+    collections: [
+      { slug: "glossary", name: "Glossary", description: "Agency and client terminology", fields: [{ key: "canonical", label: "Canonical", type: "string", required: true, searchable: true }, { key: "category", label: "Category", type: "string" }] },
+      { slug: "clients", name: "Clients", description: "Client profiles and relationship context", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "industry", label: "Industry", type: "string" }, { key: "contact", label: "Primary Contact", type: "string" }] },
+      { slug: "deliverables", name: "Deliverables", description: "Standard deliverable types and templates", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "type", label: "Type", type: "string" }, { key: "estimatedHours", label: "Estimated Hours", type: "string" }] },
+      { slug: "processes", name: "Processes", description: "Standard operating procedures and workflows", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "steps", label: "Steps", type: "string" }, { key: "owner", label: "Owner", type: "string" }] },
+      { slug: "decisions", name: "Decisions", description: "Strategic and operational decisions", fields: [{ key: "rationale", label: "Rationale", type: "string", required: true, searchable: true }, { key: "date", label: "Date", type: "string" }] },
+      { slug: "tensions", name: "Tensions", description: "Process bottlenecks and client friction", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "priority", label: "Priority", type: "select", options: ["low", "medium", "high", "critical"] }] }
+    ]
+  },
+  {
+    id: "saas-api",
+    name: "SaaS API",
+    description: "For API-first SaaS products \u2014 endpoints, schemas, rate limits, changelog, and integration guides",
+    collections: [
+      { slug: "glossary", name: "Glossary", description: "API and domain terminology", fields: [{ key: "canonical", label: "Canonical", type: "string", required: true, searchable: true }, { key: "category", label: "Category", type: "string" }] },
+      { slug: "api-endpoints", name: "API Endpoints", description: "API routes and contracts", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "method", label: "Method", type: "select", options: ["GET", "POST", "PUT", "PATCH", "DELETE"] }, { key: "path", label: "Path", type: "string" }, { key: "auth", label: "Auth", type: "select", options: ["none", "api-key", "bearer", "oauth"] }] },
+      { slug: "schemas", name: "Schemas", description: "Data models and API schemas", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "format", label: "Format", type: "select", options: ["json", "protobuf", "graphql", "openapi"] }, { key: "version", label: "Version", type: "string" }] },
+      { slug: "rate-limits", name: "Rate Limits", description: "Rate limiting policies and tiers", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "tier", label: "Tier", type: "string" }, { key: "limit", label: "Limit", type: "string" }] },
+      { slug: "changelog", name: "Changelog", description: "API version history and breaking changes", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "version", label: "Version", type: "string" }, { key: "date", label: "Date", type: "string" }, { key: "breaking", label: "Breaking", type: "select", options: ["yes", "no"] }] },
+      { slug: "decisions", name: "Decisions", description: "API design decisions and rationale", fields: [{ key: "rationale", label: "Rationale", type: "string", required: true, searchable: true }, { key: "date", label: "Date", type: "string" }] }
+    ]
+  },
+  {
+    id: "general",
+    name: "General",
+    description: "A minimal starter set \u2014 glossary, decisions, and tensions. Add more collections as you need them.",
+    collections: [
+      { slug: "glossary", name: "Glossary", description: "Canonical terminology", fields: [{ key: "canonical", label: "Canonical", type: "string", required: true, searchable: true }, { key: "category", label: "Category", type: "string" }] },
+      { slug: "decisions", name: "Decisions", description: "Decisions with rationale", fields: [{ key: "rationale", label: "Rationale", type: "string", required: true, searchable: true }, { key: "date", label: "Date", type: "string" }, { key: "decidedBy", label: "Decided By", type: "string" }] },
+      { slug: "tensions", name: "Tensions", description: "Friction points and unmet needs", fields: [{ key: "description", label: "Description", type: "string", required: true, searchable: true }, { key: "priority", label: "Priority", type: "select", options: ["low", "medium", "high", "critical"] }] }
+    ]
+  }
+];
+function getPreset(id) {
+  return COLLECTION_PRESETS.find((p) => p.id === id);
+}
+function listPresets() {
+  return COLLECTION_PRESETS.map((p) => ({
+    id: p.id,
+    name: p.name,
+    description: p.description,
+    collectionCount: p.collections.length
+  }));
+}
+
+// src/tools/start.ts
+function registerStartTools(server2) {
+  server2.registerTool(
+    "start",
+    {
+      title: "Start Product Brain",
+      description: "The zero-friction entry point. Say 'start PB' to begin.\n\n- **Fresh workspace**: asks what you're building, seeds tailored collections, and gets you ready to capture knowledge immediately.\n- **Existing workspace**: returns readiness score, recent activity, open tensions, and suggested next actions (same as orient).\n\nUse this as your first call. Replaces the need to call orient, workspace-status, or health separately.",
+      inputSchema: {
+        preset: z9.string().optional().describe(
+          "Collection preset ID to seed (e.g. 'software-product', 'content-business', 'agency', 'saas-api', 'general'). Only used for fresh workspaces. If omitted on a fresh workspace, returns the preset menu."
+        )
+      },
+      annotations: { readOnlyHint: false }
+    },
+    async ({ preset }) => {
+      const errors = [];
+      const agentSessionId = getAgentSessionId();
+      let wsCtx = null;
+      try {
+        wsCtx = await getWorkspaceContext();
+      } catch (e) {
+        errors.push(`Workspace: ${e.message}`);
+      }
+      if (!wsCtx) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "# Could not connect to Product Brain\n\n" + (errors.length > 0 ? errors.map((e) => `- ${e}`).join("\n") : "Check your API key and CONVEX_SITE_URL.")
+            }
+          ]
+        };
+      }
+      const isFresh = await detectFreshWorkspace();
+      if (isFresh && !preset) {
+        return { content: [{ type: "text", text: buildPresetMenu(wsCtx) }] };
+      }
+      if (isFresh && preset) {
+        return { content: [{ type: "text", text: await seedPreset(wsCtx, preset, agentSessionId) }] };
+      }
+      return { content: [{ type: "text", text: await buildOrientResponse(wsCtx, agentSessionId, errors) }] };
+    }
+  );
+}
+async function detectFreshWorkspace() {
+  try {
+    const entries = await mcpQuery("chain.listEntries", {});
+    const nonSystem = (entries ?? []).filter((e) => !e.isSystem);
+    return nonSystem.length === 0;
+  } catch {
+    return false;
+  }
+}
+function buildPresetMenu(wsCtx) {
+  const presets = listPresets();
+  const lines = [
+    `# Welcome to ${wsCtx.workspaceName}`,
+    "",
+    "Your workspace is fresh \u2014 let's get it set up together.",
+    "",
+    "**Tell me: what are you building?** Describe it in a sentence or two and I'll help you pick the right structure. Or choose a preset to start from:",
+    ""
+  ];
+  for (const p of presets) {
+    lines.push(`- **${p.name}** (\`${p.id}\`) \u2014 ${p.description} (${p.collectionCount} collections)`);
+  }
+  lines.push(
+    "",
+    'Call `start` again with your choice, e.g.: `start preset="software-product"`',
+    "",
+    "_These are starting points. You can add, remove, or customize collections at any time using `create-collection` and `update-collection`._"
+  );
+  return lines.join("\n");
+}
+async function seedPreset(wsCtx, presetId, agentSessionId) {
+  const preset = getPreset(presetId);
+  if (!preset) {
+    return `Preset "${presetId}" not found.
+
+Available presets: ${listPresets().map((p) => `\`${p.id}\``).join(", ")}`;
+  }
+  const seeded = [];
+  const skipped = [];
+  for (const col of preset.collections) {
+    try {
+      await mcpCall("chain.createCollection", {
+        slug: col.slug,
+        name: col.name,
+        description: col.description,
+        icon: col.icon,
+        fields: col.fields,
+        isDefault: false,
+        createdBy: "preset:" + presetId
+      });
+      seeded.push(col.name);
+    } catch {
+      skipped.push(`${col.name} (already exists)`);
+    }
+  }
+  if (agentSessionId) {
+    try {
+      await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+      setSessionOriented(true);
+    } catch {
+    }
+  }
+  const lines = [
+    `# ${wsCtx.workspaceName} is ready`,
+    "",
+    `Seeded **${preset.name}** preset with ${seeded.length} collection${seeded.length === 1 ? "" : "s"}:`,
+    ""
+  ];
+  for (const name of seeded) {
+    lines.push(`- ${name}`);
+  }
+  if (skipped.length > 0) {
+    lines.push("", "Skipped (already exist):");
+    for (const name of skipped) {
+      lines.push(`- ${name}`);
+    }
+  }
+  lines.push(
+    "",
+    "## Let's activate your workspace",
+    "",
+    "I'll help you load knowledge step by step. Everything stays as a draft until you confirm it.",
+    "",
+    "**First:** Tell me what you're building in one or two sentences. I'll capture it as your product vision.",
+    "",
+    `_After that, we'll add a few key terms to your glossary and any important decisions. Each entry is a draft \u2014 say "commit" or "looks good" when you're happy with it, and I'll promote it to the Chain (SSOT)._`,
+    "",
+    "You can also customize your structure anytime: `create-collection`, `update-collection`, or `list-collections`.",
+    "",
+    "---",
+    "Orientation complete. Write tools are available."
+  );
+  return lines.join("\n");
+}
+function computeWorkspaceAge(createdAt) {
+  if (!createdAt) return { ageDays: 0, isNeglected: false };
+  const ageDays = Math.floor((Date.now() - createdAt) / (1e3 * 60 * 60 * 24));
+  return { ageDays, isNeglected: ageDays >= 30 };
+}
+function pickNextAction(gaps, openTensions, priorSessions) {
+  if (gaps.length === 0 && openTensions.length === 0) return null;
+  if (gaps.length > 0) {
+    const gap = gaps[0];
+    const ctaMap = {
+      "strategy-vision": "Tell me what you're building \u2014 your vision, mission, and north star \u2014 and I'll capture it.",
+      "architecture-layers": "Describe your architecture in a few sentences and I'll capture it.",
+      "glossary-foundation": "What are the key terms your team uses? Tell me a few and I'll add them to the glossary.",
+      "decisions-documented": "What's a recent significant decision your team made? I'll document it with the rationale.",
+      "tensions-tracked": "What's a friction point or pain point you're dealing with? I'll capture it as a tension."
+    };
+    const cta = ctaMap[gap.id] ?? `Tell me about your ${gap.label.toLowerCase()} and I'll capture it.`;
+    return { action: gap.label, cta };
+  }
+  if (openTensions.length > 0) {
+    const t = openTensions[0];
+    return {
+      action: `Open tension: ${t.name}`,
+      cta: "Want to discuss this tension or capture a decision about it?"
+    };
+  }
+  return null;
+}
+async function buildOrientResponse(wsCtx, agentSessionId, errors) {
+  const wsFullCtx = await getWorkspaceContext();
+  const { ageDays, isNeglected } = computeWorkspaceAge(wsFullCtx.createdAt);
+  let priorSessions = [];
+  try {
+    priorSessions = await mcpQuery("agent.recentSessions", { limit: 3 });
+  } catch {
+  }
+  let openTensions = [];
+  try {
+    const tensions = await mcpQuery("chain.listEntries", { collectionSlug: "tensions" });
+    openTensions = (tensions ?? []).filter((e) => e.status === "draft");
+  } catch {
+  }
+  let readiness = null;
+  try {
+    readiness = await mcpQuery("chain.workspaceReadiness");
+  } catch (e) {
+    errors.push(`Readiness: ${e.message}`);
+  }
+  const lines = [];
+  const isLowReadiness = readiness && readiness.score < 50;
+  const isHighReadiness = readiness && readiness.score >= 50;
+  lines.push(`# ${wsCtx.workspaceName}`);
+  lines.push(`_Workspace \`${wsCtx.workspaceSlug}\` \u2014 Product Brain is healthy._`);
+  lines.push("");
+  if (isLowReadiness && isNeglected) {
+    lines.push(`Your workspace has been around for ${ageDays} days but is only ${readiness.score}% ready.`);
+    lines.push("Let's close the gaps \u2014 or if the current structure doesn't fit, we can reshape it.");
+    lines.push("");
+  } else if (isLowReadiness) {
+    lines.push(`Readiness: ${readiness.score}%. Let's get your workspace active.`);
+    lines.push("");
+  }
+  if (isLowReadiness) {
+    const nextAction = pickNextAction(readiness.gaps ?? [], openTensions, priorSessions);
+    if (nextAction) {
+      lines.push("## Recommended next step");
+      lines.push(`**${nextAction.action}**`);
+      lines.push("");
+      lines.push(nextAction.cta);
+      lines.push("");
+      lines.push('_Everything stays as a draft until you confirm. Say "commit" or "looks good" to promote to the Chain._');
+      lines.push("");
+      const remainingGaps = (readiness.gaps ?? []).length - 1;
+      if (remainingGaps > 0 || openTensions.length > 0) {
+        lines.push(`_${remainingGaps > 0 ? `${remainingGaps} more gap${remainingGaps === 1 ? "" : "s"}` : ""}${remainingGaps > 0 && openTensions.length > 0 ? " and " : ""}${openTensions.length > 0 ? `${openTensions.length} open tension${openTensions.length === 1 ? "" : "s"}` : ""} \u2014 ask "show full status" for details._`);
+        lines.push("");
+      }
+    }
+  } else if (isHighReadiness) {
+    if (readiness) {
+      lines.push(`Readiness: ${readiness.score}% (${readiness.passedChecks}/${readiness.totalChecks}).`);
+    }
+    const briefingItems = [];
+    if (openTensions.length > 0) {
+      const topTension = openTensions[0];
+      briefingItems.push(`**${openTensions.length} open tension${openTensions.length === 1 ? "" : "s"}** \u2014 top: ${topTension.name}`);
+    }
+    if (priorSessions.length > 0) {
+      const last = priorSessions[0];
+      const date = new Date(last.startedAt).toISOString().split("T")[0];
+      const created = Array.isArray(last.entriesCreated) ? last.entriesCreated.length : last.entriesCreated ?? 0;
+      const modified = Array.isArray(last.entriesModified) ? last.entriesModified.length : last.entriesModified ?? 0;
+      briefingItems.push(`**Last session** (${date}): ${created} created, ${modified} modified`);
+    }
+    if (readiness?.gaps?.length > 0) {
+      briefingItems.push(`**${readiness.gaps.length} gap${readiness.gaps.length === 1 ? "" : "s"}** remaining`);
+    }
+    if (briefingItems.length > 0) {
+      lines.push("");
+      lines.push("## Briefing");
+      for (const item of briefingItems) {
+        lines.push(`- ${item}`);
+      }
+      lines.push("");
+    }
+    lines.push("What would you like to work on?");
+    lines.push("");
+  }
+  if (errors.length > 0) {
+    lines.push("## Errors");
+    for (const err of errors) lines.push(`- ${err}`);
+    lines.push("");
+  }
+  if (agentSessionId) {
+    try {
+      await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+      setSessionOriented(true);
+      lines.push("---");
+      lines.push(
+        `Orientation complete. Session ${agentSessionId}. Write tools available.`
+      );
+    } catch {
+      lines.push("---");
+      lines.push("_Warning: Could not mark session as oriented. Write tools may be restricted._");
+    }
+  } else {
+    lines.push("---");
+    lines.push("_No active agent session. Call `agent-start` to begin a tracked session._");
+  }
+  return lines.join("\n");
+}
+
+// src/resources/index.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function formatEntryMarkdown(entry) {
+  const id = entry.entryId ? `${entry.entryId}: ` : "";
+  const lines = [`## ${id}${entry.name} [${entry.status}]`];
+  if (entry.data && typeof entry.data === "object") {
+    for (const [key, val] of Object.entries(entry.data)) {
+      if (val && key !== "rawData") {
+        lines.push(`**${key}**: ${typeof val === "string" ? val : JSON.stringify(val)}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function buildOrientationMarkdown(collections, trackingEvents, standards, businessRules) {
+  const sections = ["# Product Brain \u2014 Orientation"];
+  sections.push(
+    "## Core Product Architecture\nThe Chain is a versioned, connected, compounding knowledge base \u2014 the SSOT for a product team.\nEverything on the Chain is one of **three primitives**:\n\n- **Entry** (atom) \u2014 a discrete knowledge unit: target audience, business rule, glossary term, metric, tension. Lives in a collection.\n- **Process** (authored) \u2014 a narrative chain with named links (Strategy Coherence, IDM Proposal). Content is inline text. Collection: `chains`.\n- **Map** (composed) \u2014 a framework assembled by reference (Lean Canvas, Empathy Map). Slots point to ingredient entries. Collection: `maps`.\n\nEntries are atoms. Processes author narrative from atoms. Maps compose frameworks from atoms.\nAll three share the same versioning, branching, gating, and relation system.\n\nThe Chain compounds: each new relation makes entries discoverable from more starting points \u2192 gather-context returns richer results \u2192 AI processes have more context \u2192 quality scores improve \u2192 next commit is smarter than the last."
+  );
+  sections.push(
+    "## Architecture\n```\nCursor (stdio) \u2192 MCP Server (mcp-server/src/index.ts)\n  \u2192 POST /api/mcp with Bearer token\n  \u2192 Convex HTTP Action (convex/http.ts)\n  \u2192 internalQuery / internalMutation (convex/mcpKnowledge.ts)\n  \u2192 Convex DB (workspace-scoped)\n```\nSecurity: API key auth on every request, workspace-scoped data, internal functions blocked from external clients.\nKey files: `packages/mcp-server/src/client.ts` (HTTP client + audit), `convex/schema.ts` (schema)."
+  );
+  if (collections) {
+    const collList = collections.map((c) => {
+      const prefix = c.icon ? `${c.icon} ` : "";
+      return `- ${prefix}**${c.name}** (\`${c.slug}\`) \u2014 ${c.description || "no description"}`;
+    }).join("\n");
+    sections.push(
+      `## Data Model (${collections.length} collections)
+Unified entries model: collections define field schemas, entries hold data in a flexible \`data\` field.
+The \`data\` field is polymorphic: plain fields for generic entries, \`ChainData\` (chainTypeId + links) for processes, \`MapData\` (templateId + slots) for maps.
+Tags for filtering (e.g. \`severity:high\`), relations via \`entryRelations\`, versions via \`entryVersions\`, 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";
@@ -3262,16 +3862,16 @@ Draft a new rule: use the \`draft-rule-from-context\` prompt.`
 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\`.`
+Browse: \`list-entries collection=tracking-events\`.`
   );
   sections.push(
-    "## Knowledge Graph\nEntries are connected via typed relations (`entryRelations` table). Relations are bidirectional and collection-agnostic \u2014 any entry can link to any other entry.\n\n**Recommended relation types** (extensible \u2014 any string accepted):\n- `governs` \u2014 a rule constrains behavior of a feature\n- `defines_term_for` \u2014 a glossary term is canonical vocabulary for a feature/area\n- `belongs_to` \u2014 a feature belongs to a product area or parent concept\n- `informs` \u2014 a decision or insight informs a feature\n- `surfaces_tension_in` \u2014 a tension exists within a feature area\n- `related_to`, `depends_on`, `replaces`, `conflicts_with`, `references`, `confused_with`\n\nEach relation type is defined as a glossary entry (prefix `GT-REL-*`) to prevent terminology drift.\n\n**Tools:**\n- `gather-context` \u2014 get the full context around any entry (multi-hop graph traversal)\n- `suggest-links` \u2014 discover potential connections for an entry\n- `relate-entries` \u2014 create a typed link between two entries\n- `find-related` \u2014 list direct relations for an entry\n\n**Convention:** When creating or updating entries in governed collections, always use `suggest-links` to discover and create relevant relations."
+    "## 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- `fills_slot` \u2014 an ingredient entry fills a slot in a map\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 `capture` as the only 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 chain (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`, `features`.\nAll other collections use sensible defaults.\n\nExample: `capture collection='tensions' name='...' description='...'`\n\nUse `quality-check` to score existing entries retroactively.\nUse `update-entry` for post-creation adjustments when you need full field control."
+    "## Creating Knowledge\n**Entries:** Use `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 chain (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`, `features`, `audiences`, `strategy`, `standards`, `maps`, `chains`, `tracking-events`.\nAll other collections use the `ENT-{random}` fallback profile.\n\n**Processes:** Use `chain action=create` with a template (e.g., `strategy-coherence`, `idm-proposal`). Fill links with `chain action=edit`.\n\n**Maps:** Use `map action=create` with a template (e.g., `lean-canvas`). Fill slots with `map-slot action=add`. Commit with `map-version action=commit`.\nNote: committing a map version creates a snapshot but does NOT change the entry status. To activate: `update-entry entryId=MAP-xxx status=active autoPublish=true`.\nUse `map-suggest` to discover ingredients for empty slots.\n\n**Prompts** (invoke via MCP prompt protocol):\n- `name-check` \u2014 verify a name against glossary conventions\n- `draft-decision-record` \u2014 scaffold a decision entry\n- `review-against-rules` \u2014 check work against business rules for a domain\n- `draft-rule-from-context` \u2014 create a new business rule from context\n- `run-workflow` \u2014 run a structured ceremony (e.g., retrospective)\n\nUse `quality-check` to score existing entries retroactively.\nUse `update-entry` for post-creation adjustments (status changes, field updates, deprecation)."
   );
   sections.push(
-    "## Where to Go Next\n- **Create entry** \u2192 `capture` tool (auto-links + quality score in one call)\n- **Full context** \u2192 `gather-context` tool (by entry ID or task description)\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 `labels` tool\n- **Any collection** \u2192 `productbrain://{slug}/entries` resource\n- **Log a decision** \u2192 `draft-decision-record` prompt\n- **Architecture map** \u2192 `architecture action=show` tool (layered system visualization)\n- **Explore a layer** \u2192 `architecture action=explore` tool (drill into Auth, Core, Features, etc.)\n- **Health check** \u2192 `health` tool\n- **Debug MCP calls** \u2192 `mcp-audit` tool"
+    "## Where to Go Next\n- **Create entry** \u2192 `capture` tool (auto-links + quality score in one call)\n- **Full context** \u2192 `gather-context` tool (by entry ID or task description)\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 `labels` tool\n- **Any collection** \u2192 `productbrain://{slug}/entries` resource\n- **Log a decision** \u2192 `draft-decision-record` prompt\n- **Build a map** \u2192 `map action=create` + `map-slot action=add` + `map-version action=commit`\n- **Architecture map** \u2192 `architecture action=show` tool (layered system visualization)\n- **Explore a layer** \u2192 `architecture action=explore` tool (drill into Auth, Core, Features, etc.)\n- **Growth funnel** \u2192 `productbrain://growth-funnel` resource or `list-entries collection=strategy status=draft`\n- **Audiences** \u2192 `productbrain://audiences/entries` resource or `list-entries collection=audiences`\n- **Session identity** \u2192 `whoami` tool (workspace + auth context)\n- **Health check** \u2192 `health` tool\n- **Debug MCP calls** \u2192 `mcp-audit` tool"
   );
   return sections.join("\n\n---\n\n");
 }
@@ -3281,10 +3881,10 @@ function registerResources(server2) {
     "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" })
+        mcpQuery("chain.listCollections"),
+        mcpQuery("chain.listEntries", { collectionSlug: "tracking-events" }),
+        mcpQuery("chain.listEntries", { collectionSlug: "standards" }),
+        mcpQuery("chain.listEntries", { collectionSlug: "business-rules" })
       ]);
       const collections = collectionsResult.status === "fulfilled" ? collectionsResult.value : null;
       const trackingEvents = eventsResult.status === "fulfilled" ? eventsResult.value : null;
@@ -3304,8 +3904,8 @@ function registerResources(server2) {
     "productbrain://terminology",
     async (uri) => {
       const [glossaryResult, standardsResult] = await Promise.allSettled([
-        mcpQuery("kb.listEntries", { collectionSlug: "glossary" }),
-        mcpQuery("kb.listEntries", { collectionSlug: "standards" })
+        mcpQuery("chain.listEntries", { collectionSlug: "glossary" }),
+        mcpQuery("chain.listEntries", { collectionSlug: "standards" })
       ]);
       const lines = ["# Product Brain \u2014 Terminology"];
       if (glossaryResult.status === "fulfilled") {
@@ -3341,7 +3941,7 @@ ${stds}`);
     "chain-collections",
     "productbrain://collections",
     async (uri) => {
-      const collections = await mcpQuery("kb.listCollections");
+      const collections = await mcpQuery("chain.listCollections");
       if (collections.length === 0) {
         return { contents: [{ uri: uri.href, text: "No collections in this workspace.", mimeType: "text/markdown" }] };
       }
@@ -3364,7 +3964,7 @@ ${formatted}`, mimeType: "text/markdown" }]
     "chain-collection-entries",
     new ResourceTemplate("productbrain://{slug}/entries", {
       list: async () => {
-        const collections = await mcpQuery("kb.listCollections");
+        const collections = await mcpQuery("chain.listCollections");
         return {
           resources: collections.map((c) => ({
             uri: `productbrain://${c.slug}/entries`,
@@ -3374,7 +3974,7 @@ ${formatted}`, mimeType: "text/markdown" }]
       }
     }),
     async (uri, { slug }) => {
-      const entries = await mcpQuery("kb.listEntries", { collectionSlug: slug });
+      const entries = await mcpQuery("chain.listEntries", { collectionSlug: slug });
       const formatted = entries.map(formatEntryMarkdown).join("\n\n---\n\n");
       return {
         contents: [{
@@ -3389,7 +3989,7 @@ ${formatted}`, mimeType: "text/markdown" }]
     "chain-labels",
     "productbrain://labels",
     async (uri) => {
-      const labels = await mcpQuery("kb.listLabels");
+      const labels = await mcpQuery("chain.listLabels");
       if (labels.length === 0) {
         return { contents: [{ uri: uri.href, text: "No labels in this workspace.", mimeType: "text/markdown" }] };
       }
@@ -3419,14 +4019,14 @@ ${lines.join("\n")}`, mimeType: "text/markdown" }]
 }
 
 // src/prompts/index.ts
-import { z as z9 } from "zod";
+import { z as z10 } 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: z9.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z10.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
     async ({ domain }) => {
-      const entries = await mcpQuery("kb.listEntries", { collectionSlug: "business-rules" });
+      const entries = await mcpQuery("chain.listEntries", { collectionSlug: "business-rules" });
       const rules = entries.filter((e) => e.data?.domain === domain);
       if (rules.length === 0) {
         return {
@@ -3477,9 +4077,9 @@ Provide a structured review with a compliance status for each rule (COMPLIANT /
   server2.prompt(
     "name-check",
     "Check variable names, field names, or API names against the glossary for terminology alignment. Flags drift from canonical terms.",
-    { names: z9.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z10.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 terms = await mcpQuery("chain.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(", ")}` : "")
@@ -3513,9 +4113,9 @@ 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: z9.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z10.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 recentDecisions = await mcpQuery("chain.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 {
@@ -3551,11 +4151,11 @@ After drafting, I can log it using the capture tool with collection "decisions".
     "draft-rule-from-context",
     "Draft a new business rule from an observation or discovery made while coding. Fetches existing rules for the domain to ensure consistency.",
     {
-      observation: z9.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
-      domain: z9.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z10.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z10.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 allRules = await mcpQuery("chain.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;
@@ -3597,10 +4197,10 @@ Make sure the rule is consistent with existing rules and doesn't contradict them
     "run-workflow",
     "Launch a Chainwork workflow (retro, shape, IDM) in Facilitator Mode. Returns the full workflow definition, facilitation instructions, and round structure. The agent enters Facilitator Mode and guides the participant through each round.",
     {
-      workflow: z9.string().describe(
+      workflow: z10.string().describe(
         "Workflow ID to run. Available: " + listWorkflows().map((w) => `'${w.id}' (${w.name})`).join(", ")
       ),
-      context: z9.string().optional().describe(
+      context: z10.string().optional().describe(
         "Optional context from the participant (e.g., 'retro on last sprint', 'shape the Chainwork API bet')"
       )
     },
@@ -3627,7 +4227,7 @@ Use one of these IDs to run a workflow.`
       }
       let kbContext = "";
       try {
-        const recentDecisions = await mcpQuery("kb.listEntries", {
+        const recentDecisions = await mcpQuery("chain.listEntries", {
           collectionSlug: wf.kbOutputCollection
         });
         const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
@@ -3716,23 +4316,9 @@ if (!process.env.CONVEX_SITE_URL && !process.env.PRODUCTBRAIN_API_KEY) {
   } catch {
   }
 }
-bootstrapCloudMode();
+bootstrap();
 var SERVER_VERSION = "2.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, or run `npx productbrain setup`." : "";
-  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",
@@ -3745,28 +4331,39 @@ var server = new McpServer2(
       "Terminology, standards, and core data all live here \u2014 no need to check external docs.",
       "",
       "Workflow:",
-      "  1. Verify: call `health` to confirm connectivity.",
-      "  2. Terminology: fetch `productbrain://terminology` or use `name-check` prompt.",
+      "  1. Start: call `agent-start` to begin a tracked session.",
+      "  2. Orient: call `orient` to load workspace context and unlock write tools.",
       "  3. Discover: use `search` to find entries, or `list-entries` to browse.",
       "  4. Drill in: use `get-entry` for full details \u2014 data, labels, relations, history.",
       "  5. Context: use `gather-context` with an entryId or a task description.",
       "  6. Capture: use `capture` to create entries \u2014 auto-links and scores in one call.",
-      "  7. Connect: use `suggest-links` then `relate-entries` to build the graph.",
-      "  8. Quality: use `quality-check` to assess entry completeness.",
-      "  9. Labels: use `labels` to list, create, or apply labels.",
-      "  10. Debug: use `mcp-audit` to see what backend calls happened this session.",
+      "  7. Commit: use `commit-entry` to promote drafts to SSOT \u2014 only when the user confirms.",
+      "  8. Connect: use `suggest-links` then `relate-entries` to build the graph.",
+      "  9. Close: call `agent-close` when done \u2014 records session activity.",
+      "",
+      "Write tools (capture, update-entry, relate-entries, commit-entry) require:",
+      "  - An active agent session (call agent-start)",
+      "  - Completed orientation (call orient)",
+      "  - A readwrite API key scope",
       "",
-      "Always discover before drilling in (search or list-entries before get-entry).",
+      "Commit-on-confirm: always capture as draft first and show the user what was captured.",
+      "Only call `commit-entry` when the user explicitly confirms (e.g. 'commit', 'looks good', 'yes').",
+      "This builds trust \u2014 the Chain (main) is SSOT; nothing goes there without user consent.",
       "",
-      "Orientation:",
-      "  Fetch `productbrain://orientation` to understand architecture, data model, rules,",
-      "  and analytics. It is the map. Then use tools to drill in."
+      "Workspace setup: use `create-collection` and `update-collection` to shape the workspace",
+      "structure with the user. Ask what they need to track; presets are starting points, not fixed.",
+      "",
+      "Personalization: if you have context about the user from memory (prior work, recent",
+      "conversations, team context), use it to personalize recommendations. For example,",
+      "'Based on your recent pitch reviews, the gap most likely to matter is X.'",
+      "The orient/start output gives you the workspace state; your memory fills in the human context."
     ].join("\n")
   }
 );
 var enabledModules = new Set(
-  (process.env.PB_MODULES ?? "core,gitchain").split(",").map((m) => m.trim().toLowerCase())
+  (process.env.PB_MODULES ?? "core,gitchain,arch").split(",").map((m) => m.trim().toLowerCase())
 );
+registerSessionTools(server);
 registerKnowledgeTools(server);
 registerLabelTools(server);
 registerHealthTools(server);
@@ -3774,15 +4371,40 @@ registerVerifyTools(server);
 registerSmartCaptureTools(server);
 registerWorkflowTools(server);
 if (enabledModules.has("gitchain")) registerGitChainTools(server);
+if (enabledModules.has("gitchain")) registerMapTools(server);
 if (enabledModules.has("arch")) registerArchitectureTools(server);
+registerStartTools(server);
 registerResources(server);
 registerPrompts(server);
 var transport = new StdioServerTransport();
 await server.connect(transport);
+getWorkspaceId().then(async (wsId) => {
+  trackSessionStarted(wsId, SERVER_VERSION);
+  try {
+    await startAgentSession();
+    process.stderr.write("[MCP] Agent session started automatically.\n");
+  } catch (err) {
+    process.stderr.write(`[MCP] Auto session start failed: ${err.message}. Call agent-start manually.
+`);
+    await recoverSessionState();
+  }
+}).catch(() => {
+  process.stderr.write("[MCP] Workspace resolution deferred \u2014 will retry on first tool call.\n");
+});
 async function gracefulShutdown() {
+  if (getAgentSessionId()) {
+    await orphanAgentSession();
+  }
   await shutdownAnalytics();
   process.exit(0);
 }
 process.on("SIGINT", gracefulShutdown);
 process.on("SIGTERM", gracefulShutdown);
+process.stdin.on("end", async () => {
+  if (getAgentSessionId()) {
+    await orphanAgentSession();
+  }
+  await shutdownAnalytics();
+  process.exit(0);
+});
 //# sourceMappingURL=index.js.map