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

package/dist/index.js

@@ -191,7 +191,7 @@ function registerKnowledgeTools(server2) {
     "list-collections",
     {
       title: "Browse Collections",
-      description: "List every knowledge collection in the workspace \u2014 glossary, business rules, tracking events, standards, etc. Returns each collection's slug, name, description, and field schema. Start here before create-entry so you know which collections exist and what fields they expect.",
+      description: "List every knowledge collection in the workspace \u2014 glossary, business rules, tracking events, standards, etc. Returns each collection's slug, name, description, and field schema. Start here before capture so you know which collections exist and what fields they expect.",
       annotations: { readOnlyHint: true }
     },
     async () => {
@@ -260,7 +260,7 @@ ${formatted}` }]
     "get-entry",
     {
       title: "Look Up Entry",
-      description: "Retrieve a single knowledge entry by its human-readable ID (e.g. 'T-SUPPLIER', 'BR-001', 'EVT-workspace_created'). Returns the full record: all data fields, labels, relations, and change history. Use kb-search or list-entries first to discover entry IDs.",
+      description: "Retrieve a single knowledge entry by its human-readable ID (e.g. 'T-SUPPLIER', 'BR-001', 'EVT-workspace_created'). Returns the full record: all data fields, labels, relations, and change history. Use search or list-entries first to discover entry IDs.",
       inputSchema: {
         entryId: z.string().describe("Entry ID, e.g. 'T-SUPPLIER', 'BR-001', 'EVT-workspace_created'")
       },
@@ -269,7 +269,7 @@ ${formatted}` }]
     async ({ entryId }) => {
       const entry = await mcpQuery("kb.getEntry", { entryId });
       if (!entry) {
-        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }] };
       }
       const lines = [
         `# ${entry.entryId ? `${entry.entryId}: ` : ""}${entry.name}`,
@@ -307,81 +307,6 @@ ${formatted}` }]
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
   );
-  const governedCollections = /* @__PURE__ */ new Set([
-    "glossary",
-    "business-rules",
-    "principles",
-    "standards",
-    "strategy"
-  ]);
-  server2.registerTool(
-    "create-entry",
-    {
-      title: "Create Entry",
-      description: "Create a new knowledge entry. Provide the collection slug, a display name, status, and data matching the collection's field schema. Call list-collections first to see available collections and their field definitions. Governed collections (glossary, business-rules, principles, standards, strategy) require status 'draft' \u2014 to promote to 'active' or 'verified', raise a tension or use update-entry after approval.",
-      inputSchema: {
-        collection: z.string().describe("Collection slug, e.g. 'tracking-events', 'standards', 'glossary'"),
-        entryId: z.string().optional().describe("Human-readable ID, e.g. 'EVT-workspace_created', 'STD-posthog-events'"),
-        name: z.string().describe("Display name"),
-        status: z.string().default("draft").describe("Lifecycle status: draft | active | verified | deprecated"),
-        data: z.record(z.unknown()).describe("Data object \u2014 keys must match the collection's field definitions"),
-        order: z.number().optional().describe("Manual sort order within the collection")
-      },
-      annotations: { destructiveHint: false }
-    },
-    async ({ collection, entryId, name, status, data, order }) => {
-      if (governedCollections.has(collection) && status !== "draft" && status !== "deprecated") {
-        return {
-          content: [{
-            type: "text",
-            text: `# Governance Required
-
-The \`${collection}\` collection is governed. New entries must be created with status \`draft\`.
-
-**How to proceed:**
-1. Create the entry with status \`draft\` (treated as a proposal)
-2. Raise a tension in the \`tensions\` collection to request promotion
-3. After approval, use \`update-entry\` to change status to \`active\` or \`verified\``
-          }]
-        };
-      }
-      try {
-        const id = await mcpMutation("kb.createEntry", {
-          collectionSlug: collection,
-          entryId,
-          name,
-          status,
-          data,
-          order
-        });
-        return {
-          content: [{ type: "text", text: `# Entry Created
-
-**${entryId ?? name}** added to \`${collection}\` as \`${status}\`.
-
-Internal ID: ${id}` }]
-        };
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes("Duplicate entry") || msg.includes("already exists")) {
-          return {
-            content: [{
-              type: "text",
-              text: `# Cannot Create \u2014 Duplicate Detected
-
-${msg}
-
-**What to do:**
-- Use \`get-entry\` to inspect the existing entry
-- Use \`update-entry\` to modify it
-- If a genuinely new entry is needed, raise a tension to propose it`
-            }]
-          };
-        }
-        throw error;
-      }
-    }
-  );
   server2.registerTool(
     "update-entry",
     {
@@ -426,7 +351,7 @@ Internal ID: ${id}` }]
 Tension status (open, in-progress, closed) must be changed through the defined process, not via MCP.
 
 **What you can do:**
-- Create tensions: \`create-entry collection=tensions name="..." status=open\`
+- Create tensions: \`capture collection=tensions name="..." description="..."\`
 - List tensions: \`list-entries collection=tensions\`
 - Update non-status fields (raised, date, priority, description) via \`update-entry\`
 - After process approval, a human uses the Product Brain UI to change status
@@ -440,10 +365,10 @@ Process criteria (TBD): e.g. 3+ users approved, or 7 days without valid concerns
     }
   );
   server2.registerTool(
-    "kb-search",
+    "search",
     {
-      title: "Search Knowledge Base",
-      description: "Full-text search across all knowledge entries. Returns entry names, collection, status, and a description preview. Scope results to a specific collection (e.g. collection='business-rules') or filter by status (e.g. status='active'). Use this to discover entries before calling get-entry for full details.",
+      title: "Search the Chain",
+      description: "Full-text search across all entries on the Chain. Returns entry names, collection, status, and a description preview. Scope results to a specific collection (e.g. collection='business-rules') or filter by status (e.g. status='active'). Use this to discover entries before calling get-entry for full details.",
       inputSchema: {
         query: z.string().describe("Search text (min 2 characters)"),
         collection: z.string().optional().describe("Scope to a collection slug, e.g. 'business-rules', 'glossary', 'tracking-events'"),
@@ -564,7 +489,7 @@ ${formatted}` }]
       }
       const sourceEntry = await mcpQuery("kb.getEntry", { entryId });
       if (!sourceEntry) {
-        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }] };
       }
       const sourceInternalId = sourceEntry._id;
       const MAX_RELATIONS = 25;
@@ -623,18 +548,113 @@ ${formatted}` }]
   server2.registerTool(
     "gather-context",
     {
-      title: "Gather Full Context",
-      description: "Assemble the full knowledge context around an entry by traversing the knowledge graph. Returns all related entries grouped by collection \u2014 glossary terms, business rules, tensions, decisions, features, etc. Use this when starting work on a feature or investigating an area to get the complete picture in one call.\n\nExample: gather-context entryId='FEAT-001' returns all glossary terms, business rules, and tensions linked to that feature.",
+      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.",
       inputSchema: {
-        entryId: z.string().describe("Entry ID, e.g. 'FEAT-001', 'GT-019', 'BR-007'"),
-        maxHops: z.number().min(1).max(3).default(2).describe("How many relation hops to traverse (1=direct only, 2=default, 3=wide net)")
+        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"),
+        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, maxHops }) => {
+    async ({ entryId, task, maxHops, maxResults }) => {
+      if (!entryId && !task) {
+        return { content: [{ type: "text", text: "Provide either `entryId` (graph traversal) or `task` (auto-load context for a task)." }] };
+      }
+      if (task && !entryId) {
+        await server2.sendLoggingMessage({
+          level: "info",
+          data: `Loading context for task: "${task.substring(0, 80)}..."`,
+          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", {
+          query: searchTerms
+        });
+        if (!searchResults || searchResults.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: `# Context Loaded
+
+**Confidence:** None
+
+No context found for this task. The chain may not cover this area yet.
+
+_Consider capturing domain knowledge discovered during this task via \`capture\`._`
+            }]
+          };
+        }
+        const limit = maxResults ?? 10;
+        const topHits = searchResults.slice(0, Math.min(limit, 5));
+        const allEntries = [];
+        const seenIds = /* @__PURE__ */ new Set();
+        for (const hit of topHits) {
+          const hitId = hit.entryId ?? hit._id;
+          if (!hitId || seenIds.has(hitId)) continue;
+          seenIds.add(hitId);
+          allEntries.push({
+            entryId: hit.entryId,
+            name: hit.name ?? "Untitled",
+            collectionName: hit.collectionName ?? hit.collectionSlug ?? "unknown",
+            hop: 0
+          });
+          if (hit.entryId) {
+            try {
+              const graph = await mcpQuery("kb.gatherContext", {
+                entryId: hit.entryId,
+                maxHops: maxHops ?? 2
+              });
+              if (graph?.related) {
+                for (const rel of graph.related) {
+                  const relId = rel.entryId ?? rel._id;
+                  if (relId && !seenIds.has(relId)) {
+                    seenIds.add(relId);
+                    allEntries.push({
+                      entryId: rel.entryId,
+                      name: rel.name ?? "Untitled",
+                      collectionName: rel.collectionName ?? "unknown",
+                      hop: rel.hop ?? 1,
+                      relationType: rel.relationType
+                    });
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+          if (allEntries.length >= limit) break;
+        }
+        const trimmed = allEntries.slice(0, limit);
+        const confidence = trimmed.length >= 5 ? "high" : trimmed.length >= 2 ? "medium" : "low";
+        const byCollection2 = /* @__PURE__ */ new Map();
+        for (const entry of trimmed) {
+          const key = entry.collectionName;
+          if (!byCollection2.has(key)) byCollection2.set(key, []);
+          byCollection2.get(key).push(entry);
+        }
+        const lines2 = [
+          `# Context Loaded`,
+          `**Confidence:** ${confidence.charAt(0).toUpperCase() + confidence.slice(1)}`,
+          `**Matched:** ${trimmed.length} entries across ${byCollection2.size} collection${byCollection2.size === 1 ? "" : "s"}`,
+          ""
+        ];
+        for (const [collName, entries] of byCollection2) {
+          lines2.push(`### ${collName} (${entries.length})`);
+          for (const e of entries) {
+            const id = e.entryId ? `**${e.entryId}:** ` : "";
+            const hopLabel = e.hop > 0 ? ` _(hop ${e.hop}${e.relationType ? `, ${e.relationType}` : ""})_` : "";
+            lines2.push(`- ${id}${e.name}${hopLabel}`);
+          }
+          lines2.push("");
+        }
+        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 });
       if (!result?.root) {
-        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try search to find the right ID.` }] };
       }
       if (result.related.length === 0) {
         return {
@@ -676,7 +696,7 @@ 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 knowledge base for related content. Returns ranked suggestions based on text similarity \u2014 review them and use relate-entries to create the ones that make sense.\n\nThis is a discovery tool, not auto-linking. Always review suggestions before linking.",
+      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.",
       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")
@@ -686,7 +706,7 @@ Use \`suggest-links\` to discover potential connections, or \`relate-entries\` t
     async ({ entryId, limit }) => {
       const entry = await mcpQuery("kb.getEntry", { entryId });
       if (!entry) {
-        return { content: [{ type: "text", text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.` }] };
+        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);
@@ -699,7 +719,7 @@ Use \`suggest-links\` to discover potential connections, or \`relate-entries\` t
       }
       const results = await mcpQuery("kb.searchEntries", { query: queryText });
       if (!results || results.length === 0) {
-        return { content: [{ type: "text", text: `No suggestions found for \`${entryId}\`. The knowledge base may need more entries.` }] };
+        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(
@@ -734,273 +754,59 @@ Use \`suggest-links\` to discover potential connections, or \`relate-entries\` t
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
   );
-  server2.registerTool(
-    "quick-capture",
-    {
-      title: "Quick Capture",
-      description: "Quickly capture a knowledge entry with just a name and description \u2014 no need to look up the full field schema first. Always creates as 'draft' status with sensible defaults for remaining fields. Use update-entry later to fill in details. Embodies 'Capture Now, Curate Later' (PRI-81cbdq).",
-      inputSchema: {
-        collection: z.string().describe("Collection slug, e.g. 'business-rules', 'glossary', 'tensions', 'decisions'"),
-        name: z.string().describe("Display name for the entry"),
-        description: z.string().describe("Short description \u2014 the essential context to capture now"),
-        entryId: z.string().optional().describe("Optional human-readable ID (e.g. 'SOS-020', 'GT-031')")
-      },
-      annotations: { destructiveHint: false }
-    },
-    async ({ collection, name, description, entryId }) => {
-      const col = await mcpQuery("kb.getCollection", { slug: collection });
-      if (!col) {
-        return { content: [{ type: "text", text: `Collection \`${collection}\` not found. Use list-collections to see available collections.` }] };
-      }
-      const data = {};
-      const emptyFields = [];
-      for (const field of col.fields ?? []) {
-        const key = field.key;
-        if (key === "description" || key === "canonical" || key === "detail") {
-          data[key] = description;
-        } else if (field.type === "array" || field.type === "multi-select") {
-          data[key] = [];
-          emptyFields.push(key);
-        } else if (field.type === "select") {
-          data[key] = field.options?.[0] ?? "";
-          emptyFields.push(key);
-        } else {
-          data[key] = "";
-          emptyFields.push(key);
-        }
-      }
-      if (!data.description && !data.canonical && !data.detail) {
-        data.description = description;
-      }
-      try {
-        const id = await mcpMutation("kb.createEntry", {
-          collectionSlug: collection,
-          entryId,
-          name,
-          status: "draft",
-          data
-        });
-        const emptyNote = emptyFields.length > 0 ? `
-
-**Fields to fill later** (via \`update-entry\`):
-${emptyFields.map((f) => `- \`${f}\``).join("\n")}` : "";
-        return {
-          content: [{
-            type: "text",
-            text: `# Quick Capture \u2014 Done
-
-**${entryId ?? name}** added to \`${collection}\` as \`draft\`.
-
-Internal ID: ${id}${emptyNote}
-
-_Use \`update-entry\` to fill in details when ready. Use \`get-entry\` to review._`
-          }]
-        };
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes("Duplicate") || msg.includes("already exists")) {
-          return {
-            content: [{
-              type: "text",
-              text: `# Cannot Capture \u2014 Duplicate Detected
-
-${msg}
-
-Use \`get-entry\` to inspect the existing entry, or \`update-entry\` to modify it.`
-            }]
-          };
-        }
-        throw error;
-      }
-    }
-  );
-  server2.registerTool(
-    "load-context-for-task",
-    {
-      title: "Load Context for Task",
-      description: "Auto-load relevant domain knowledge for a task in a single call. Pass a natural-language task description; the tool searches the KB, traverses the knowledge graph, and returns a ranked set of entries (business rules, glossary terms, decisions, features, etc.) grouped by collection with a confidence score.\n\nUse this at the start of a conversation to ground the agent in domain context before writing code or making recommendations.\n\nConfidence levels:\n- high: 3+ direct KB matches \u2014 strong domain coverage\n- medium: 1-2 direct matches \u2014 partial coverage, may want to drill deeper\n- low: no direct matches but related entries found via graph traversal\n- none: no relevant entries found \u2014 KB may not cover this area yet",
-      inputSchema: {
-        taskDescription: z.string().describe("Natural-language description of the task or user message"),
-        maxResults: z.number().min(1).max(25).default(10).optional().describe("Max entries to return (default 10)"),
-        maxHops: z.number().min(1).max(3).default(2).optional().describe("Graph traversal depth from each search hit (default 2)")
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ taskDescription, maxResults, maxHops }) => {
-      await server2.sendLoggingMessage({
-        level: "info",
-        data: `Loading context for task: "${taskDescription.substring(0, 80)}..."`,
-        logger: "product-brain"
-      });
-      const result = await mcpQuery("kb.loadContextForTask", {
-        taskDescription,
-        maxResults: maxResults ?? 10,
-        maxHops: maxHops ?? 2
-      });
-      if (result.confidence === "none" || result.entries.length === 0) {
-        return {
-          content: [{
-            type: "text",
-            text: `# Context Loaded
-
-**Confidence:** None
-
-No KB context found for this task. The knowledge base may not cover this area yet.
-
-_Consider capturing domain knowledge discovered during this task via \`smart-capture\`._`
-          }]
-        };
-      }
-      const byCollection = /* @__PURE__ */ new Map();
-      for (const entry of result.entries) {
-        const key = entry.collectionName;
-        if (!byCollection.has(key)) byCollection.set(key, []);
-        byCollection.get(key).push(entry);
-      }
-      const lines = [
-        `# Context Loaded`,
-        `**Confidence:** ${result.confidence.charAt(0).toUpperCase() + result.confidence.slice(1)}`,
-        `**Matched:** ${result.entries.length} entries across ${byCollection.size} collection${byCollection.size === 1 ? "" : "s"}`,
-        ""
-      ];
-      for (const [collName, entries] of byCollection) {
-        lines.push(`### ${collName} (${entries.length})`);
-        for (const e of entries) {
-          const id = e.entryId ? `**${e.entryId}:** ` : "";
-          const hopLabel = e.hop > 0 ? ` _(hop ${e.hop}${e.relationType ? `, ${e.relationType}` : ""})_` : "";
-          const preview = e.descriptionPreview ? `
-  ${e.descriptionPreview}` : "";
-          const codePaths = e.codePaths.length > 0 ? `
-  Code: ${e.codePaths.join(", ")}` : "";
-          lines.push(`- ${id}${e.name}${hopLabel}${preview}${codePaths}`);
-        }
-        lines.push("");
-      }
-      lines.push(`_Use \`get-entry\` for full details on any entry._`);
-      return {
-        content: [{ type: "text", text: lines.join("\n") }]
-      };
-    }
-  );
-  server2.registerTool(
-    "review-rules",
-    {
-      title: "Review Business Rules",
-      description: "Surface all active business rules for a domain, formatted for compliance review. Use when reviewing code, designs, or decisions against Product Brain governance. Optionally provide context (what you're building or reviewing) to help focus the review. This is the tool form of the review-against-rules prompt.",
-      inputSchema: {
-        domain: z.string().describe("Business rule domain, e.g. 'AI & MCP Integration', 'Governance & Decision-Making'"),
-        context: z.string().optional().describe("What you're reviewing \u2014 code change, design decision, file path, etc.")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ domain, context }) => {
-      const entries = await mcpQuery("kb.listEntries", { collectionSlug: "business-rules" });
-      const domainLower = domain.toLowerCase();
-      const rules = entries.filter((e) => {
-        const ruleDomain = e.data?.domain ?? "";
-        return ruleDomain.toLowerCase() === domainLower || ruleDomain.toLowerCase().includes(domainLower);
-      });
-      if (rules.length === 0) {
-        const allDomains = [...new Set(entries.map((e) => e.data?.domain).filter(Boolean))];
-        return {
-          content: [{
-            type: "text",
-            text: `# No Rules Found for "${domain}"
-
-Available domains:
-${allDomains.map((d) => `- ${d}`).join("\n")}
-
-_Try one of the domains above, or use kb-search to find rules by keyword._`
-          }]
-        };
-      }
-      const header = context ? `# Business Rules: ${domain}
-
-**Review context:** ${context}
-
-For each rule, assess: compliant, at risk, violation, or not applicable.
-` : `# Business Rules: ${domain}
-`;
-      const formatted = rules.map((r) => {
-        const id = r.entryId ? `**${r.entryId}:** ` : "";
-        const severity = r.data?.severity ? ` | Severity: ${r.data.severity}` : "";
-        const desc = r.data?.description ?? "";
-        const impact = r.data?.dataImpact ? `
-  Data impact: ${r.data.dataImpact}` : "";
-        const related = (r.data?.relatedRules ?? []).length > 0 ? `
-  Related: ${r.data.relatedRules.join(", ")}` : "";
-        return `### ${id}${r.name} \`${r.status}\`${severity}
-
-${desc}${impact}${related}`;
-      }).join("\n\n---\n\n");
-      const footer = `
-_${rules.length} rule${rules.length === 1 ? "" : "s"} in this domain. Use \`get-entry\` for full details. Use the \`draft-rule-from-context\` prompt to propose new rules._`;
-      return {
-        content: [{ type: "text", text: `${header}
-${formatted}
-${footer}` }]
-      };
-    }
-  );
 }
 
 // src/tools/labels.ts
 import { z as z2 } from "zod";
 function registerLabelTools(server2) {
   server2.registerTool(
-    "list-labels",
-    {
-      title: "Browse Labels",
-      description: "List all workspace labels with their groups and hierarchy. Labels can be applied to any entry across any collection for cross-domain filtering. Similar to labels in Linear or GitHub.",
-      annotations: { readOnlyHint: true }
-    },
-    async () => {
-      const labels = await mcpQuery("kb.listLabels");
-      if (labels.length === 0) {
-        return { content: [{ type: "text", text: "No labels defined in this workspace yet." }] };
-      }
-      const groups = labels.filter((l) => l.isGroup);
-      const ungrouped = labels.filter((l) => !l.isGroup && !l.parentId);
-      const children = (parentId) => labels.filter((l) => l.parentId === parentId);
-      const lines = ["# Workspace Labels"];
-      for (const group of groups) {
-        lines.push(`
-## ${group.name}`);
-        if (group.description) lines.push(`_${group.description}_`);
-        for (const child of children(group._id)) {
-          const color = child.color ? ` ${child.color}` : "";
-          lines.push(`  - \`${child.slug}\` ${child.name}${color}`);
-        }
-      }
-      if (ungrouped.length > 0) {
-        lines.push("\n## Ungrouped");
-        for (const label of ungrouped) {
-          const color = label.color ? ` ${label.color}` : "";
-          lines.push(`- \`${label.slug}\` ${label.name}${color}${label.description ? ` \u2014 _${label.description}_` : ""}`);
-        }
-      }
-      return {
-        content: [{ type: "text", text: lines.join("\n") }]
-      };
-    }
-  );
-  server2.registerTool(
-    "manage-labels",
+    "labels",
     {
-      title: "Manage Labels",
-      description: "Create, update, or delete a workspace label. Labels support hierarchy (groups with children). Use list-labels first to see what exists.",
+      title: "Labels",
+      description: "Manage workspace labels \u2014 list, create, update, delete, apply to entries, or remove from entries. Labels can be applied to any entry across any collection for cross-domain filtering. Similar to labels in Linear or GitHub. Labels support hierarchy (groups with children).",
       inputSchema: {
-        action: z2.enum(["create", "update", "delete"]).describe("What to do"),
-        slug: z2.string().describe("Label slug (machine name), e.g. 'p1-critical', 'needs-review'"),
+        action: z2.enum(["list", "create", "update", "delete", "apply", "remove"]).describe("Action: list all labels, create/update/delete a label, or apply/remove a label on an entry"),
+        slug: z2.string().optional().describe("Label slug (required for create/update/delete/apply/remove)"),
         name: z2.string().optional().describe("Display name (required for create)"),
         color: z2.string().optional().describe("Hex color, e.g. '#ef4444'"),
         description: z2.string().optional().describe("What this label means"),
         parentSlug: z2.string().optional().describe("Parent group slug for label hierarchy"),
         isGroup: z2.boolean().optional().describe("True if this is a group container, not a taggable label"),
-        order: z2.number().optional().describe("Sort order within its group")
+        order: z2.number().optional().describe("Sort order within its group"),
+        entryId: z2.string().optional().describe("Entry ID for apply/remove actions")
       }
     },
-    async ({ action, slug, name, color, description, parentSlug, isGroup, order }) => {
+    async ({ action, slug, name, color, description, parentSlug, isGroup, order, entryId }) => {
+      if (action === "list") {
+        const labels = await mcpQuery("kb.listLabels");
+        if (labels.length === 0) {
+          return { content: [{ type: "text", text: "No labels defined in this workspace yet." }] };
+        }
+        const groups = labels.filter((l) => l.isGroup);
+        const ungrouped = labels.filter((l) => !l.isGroup && !l.parentId);
+        const children = (parentId) => labels.filter((l) => l.parentId === parentId);
+        const lines = ["# Workspace Labels"];
+        for (const group of groups) {
+          lines.push(`
+## ${group.name}`);
+          if (group.description) lines.push(`_${group.description}_`);
+          for (const child of children(group._id)) {
+            const c = child.color ? ` ${child.color}` : "";
+            lines.push(`  - \`${child.slug}\` ${child.name}${c}`);
+          }
+        }
+        if (ungrouped.length > 0) {
+          lines.push("\n## Ungrouped");
+          for (const label of ungrouped) {
+            const c = label.color ? ` ${label.color}` : "";
+            lines.push(`- \`${label.slug}\` ${label.name}${c}${label.description ? ` \u2014 _${label.description}_` : ""}`);
+          }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+      if (!slug) {
+        return { content: [{ type: "text", text: "A `slug` is required for this action." }] };
+      }
       if (action === "create") {
         if (!name) {
           return { content: [{ type: "text", text: "Cannot create a label without a name." }] };
@@ -1010,7 +816,7 @@ function registerLabelTools(server2) {
           const labels = await mcpQuery("kb.listLabels");
           const parent = labels.find((l) => l.slug === parentSlug);
           if (!parent) {
-            return { content: [{ type: "text", text: `Parent label \`${parentSlug}\` not found. Use list-labels to see available groups.` }] };
+            return { content: [{ type: "text", text: `Parent label \`${parentSlug}\` not found. Use \`labels action=list\` to see available groups.` }] };
           }
           parentId = parent._id;
         }
@@ -1031,27 +837,18 @@ function registerLabelTools(server2) {
 
 \`${slug}\` removed from all entries and deleted.` }] };
       }
-      return { content: [{ type: "text", text: "Unknown action." }] };
-    }
-  );
-  server2.registerTool(
-    "label-entry",
-    {
-      title: "Tag Entry with Label",
-      description: "Apply or remove a label from a knowledge entry. Labels work across all collections for cross-domain filtering. Use list-labels to see available label slugs.",
-      inputSchema: {
-        action: z2.enum(["apply", "remove"]).describe("Apply or remove the label"),
-        entryId: z2.string().describe("Entry ID, e.g. 'T-SUPPLIER', 'EVT-workspace_created'"),
-        label: z2.string().describe("Label slug to apply/remove")
-      }
-    },
-    async ({ action, entryId, label }) => {
-      if (action === "apply") {
-        await mcpMutation("kb.applyLabel", { entryId, labelSlug: label });
-        return { content: [{ type: "text", text: `Label \`${label}\` applied to **${entryId}**.` }] };
+      if (action === "apply" || action === "remove") {
+        if (!entryId) {
+          return { content: [{ type: "text", text: "An `entryId` is required for apply/remove actions." }] };
+        }
+        if (action === "apply") {
+          await mcpMutation("kb.applyLabel", { entryId, labelSlug: slug });
+          return { content: [{ type: "text", text: `Label \`${slug}\` applied to **${entryId}**.` }] };
+        }
+        await mcpMutation("kb.removeLabel", { entryId, labelSlug: slug });
+        return { content: [{ type: "text", text: `Label \`${slug}\` removed from **${entryId}**.` }] };
       }
-      await mcpMutation("kb.removeLabel", { entryId, labelSlug: label });
-      return { content: [{ type: "text", text: `Label \`${label}\` removed from **${entryId}**.` }] };
+      return { content: [{ type: "text", text: "Unknown action." }] };
     }
   );
 }
@@ -1185,7 +982,7 @@ function registerHealthTools(server2) {
     "mcp-audit",
     {
       title: "Session Audit Log",
-      description: "Show a session summary (reads, writes, searches, contributions) and the last N backend calls. Useful for debugging, tracing tool behavior, and seeing what you contributed to the knowledge base.",
+      description: "Show a session summary (reads, writes, searches, contributions) and the last N backend calls. Useful for debugging, tracing tool behavior, and seeing what you contributed to the chain.",
       inputSchema: {
         limit: z3.number().min(1).max(50).default(20).describe("How many recent calls to show (max 50)")
       },
@@ -1367,7 +1164,7 @@ function registerVerifyTools(server2) {
   server2.registerTool(
     "verify",
     {
-      title: "Verify Knowledge Base",
+      title: "Verify the Chain",
       description: "Verify knowledge entries against the actual codebase. Checks glossary code mappings (do referenced files and schema fields still exist?) and validates cross-references (do relatedRules point to real entries?). Produces a trust report with a trust score. Use mode='fix' to auto-update drifted codeMapping statuses.",
       inputSchema: {
         collection: z4.string().default("glossary").describe("Collection slug to verify (default: glossary)"),
@@ -1490,7 +1287,7 @@ function registerVerifyTools(server2) {
 import { z as z5 } from "zod";
 var AREA_KEYWORDS = {
   "Architecture": ["convex", "schema", "database", "migration", "api", "backend", "infrastructure", "scaling", "performance"],
-  "Knowledge Base": ["knowledge", "glossary", "entry", "collection", "terminology", "drift", "graph"],
+  "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"],
@@ -1530,7 +1327,7 @@ var COMMON_CHECKS = {
     id: "has-relations",
     label: "At least 1 relation created",
     check: (ctx) => ctx.linksCreated.length >= 1,
-    suggestion: () => "Use `suggest-links` and `relate-entries` to connect this entry to related knowledge."
+    suggestion: () => "Use `suggest-links` and `relate-entries` to add more connections."
   },
   diverseRelations: {
     id: "diverse-relations",
@@ -1644,7 +1441,7 @@ var PROFILES = /* @__PURE__ */ new Map([
       if (area) {
         const categoryMap = {
           "Architecture": "Platform & Architecture",
-          "Knowledge Base": "Knowledge Management",
+          "Chain": "Knowledge Management",
           "AI & MCP Integration": "AI & Developer Tools",
           "Developer Experience": "AI & Developer Tools",
           "Governance & Decision-Making": "Governance & Process",
@@ -1836,7 +1633,7 @@ async function checkEntryQuality(entryId) {
   const entry = await mcpQuery("kb.getEntry", { entryId });
   if (!entry) {
     return {
-      text: `Entry \`${entryId}\` not found. Try kb-search to find the right ID.`,
+      text: `Entry \`${entryId}\` not found. Try search to find the right ID.`,
       quality: { score: 0, maxScore: 10, checks: [] }
     };
   }
@@ -1897,10 +1694,10 @@ var MAX_AUTO_LINKS = 5;
 var MAX_SUGGESTIONS = 5;
 function registerSmartCaptureTools(server2) {
   server2.registerTool(
-    "smart-capture",
+    "capture",
     {
-      title: "Smart Capture",
-      description: "One-call knowledge capture: creates an entry, auto-links related entries, and returns a quality scorecard. Replaces the multi-step workflow of create-entry + suggest-links + relate-entries. Provide a collection, name, and description \u2014 everything else is inferred or auto-filled.\n\nSupported collections with smart profiles: tensions, business-rules, glossary, decisions.\nAll other collections use sensible defaults (same as quick-capture + auto-linking).\n\nAlways creates as 'draft' for governed collections. Embodies 'Capture Now, Curate Later' (PRI-81cbdq).",
+      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')"),
@@ -1968,7 +1765,7 @@ function registerSmartCaptureTools(server2) {
           name,
           status,
           data,
-          createdBy: "smart-capture"
+          createdBy: "capture"
         });
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
@@ -2228,7 +2025,7 @@ var SEED_NODES = [
   { entryId: "ARCH-node-posthog", name: "PostHog", order: 1, data: { archType: "node", layerRef: "ARCH-layer-infra", color: "#ec4899", icon: "\u{1F4CA}", description: "Product analytics \u2014 workspace-scoped events, feature flags, session replay", filePaths: "src/lib/analytics.ts, src/lib/components/PostHogWorkspaceSync.svelte", owner: "Platform", rationale: "Infrastructure because PostHog is analytics plumbing \u2014 event collection and aggregation. It has no knowledge of business domains." } },
   { entryId: "ARCH-node-openrouter", name: "OpenRouter", order: 2, data: { archType: "node", layerRef: "ARCH-layer-infra", color: "#ec4899", icon: "\u{1F916}", description: "AI model routing for ChainWork artifact generation \u2014 streaming responses with format-aware prompts", filePaths: "src/routes/api/chainwork/generate/+server.ts", owner: "ChainWork", rationale: "Infrastructure because OpenRouter is an AI model gateway \u2014 it routes prompts to models. The strategy logic lives in ChainWork Engine (Core); this is just the pipe." } },
   // Core layer
-  { entryId: "ARCH-node-mcp", name: "MCP Server", order: 0, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u{1F527}", description: "20+ tools exposing the knowledge graph as AI-consumable operations \u2014 smart-capture, context assembly, verification, quality checks", filePaths: "packages/mcp-server/src/index.ts, packages/mcp-server/src/tools/", owner: "AI DX", rationale: "Core layer because the MCP server encodes business operations \u2014 smart-capture with auto-linking, quality scoring, governance rules. It depends on Infra (Convex) but never touches UI routes. Why not Infrastructure? Because it has domain opinions. Why not Features? Because it has no UI \u2014 any client (Cursor, CLI, API) can call it." } },
+  { entryId: "ARCH-node-mcp", name: "MCP Server", order: 0, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u{1F527}", description: "~19 modular tools exposing the knowledge graph as AI-consumable operations \u2014 capture, context assembly, verification, quality checks", filePaths: "packages/mcp-server/src/index.ts, packages/mcp-server/src/tools/", owner: "AI DX", rationale: "Core layer because the MCP server encodes business operations \u2014 capture with auto-linking, quality scoring, governance rules. It depends on Infra (Convex) but never touches UI routes. Why not Infrastructure? Because it has domain opinions. Why not Features? Because it has no UI \u2014 any client (Cursor, CLI, API) can call it." } },
   { entryId: "ARCH-node-knowledge-graph", name: "Knowledge Graph", order: 1, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u{1F578}\uFE0F", description: "20 collections, 170+ entries with typed cross-collection relations. Smart capture, auto-linking, quality scoring", filePaths: "convex/mcpKnowledge.ts, convex/entries.ts", owner: "Knowledge", rationale: "Core layer because the knowledge graph IS the domain model \u2014 collections, entries, relations, versioning, quality scoring. Glossary DATA, business rules DATA, tension DATA all live here. Why not Features? Because the data model exists independently of any page. The Glossary page in Features is just one way to visualize terms that Core owns. Think: Core owns the dictionary, Features owns the dictionary app." } },
   { entryId: "ARCH-node-governance", name: "Governance Engine", order: 2, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u2696\uFE0F", description: "Circles, roles, consent-based decision-making, tension processing with IDM-inspired async workflows", filePaths: "convex/versioning.ts, src/lib/components/versioning/", owner: "Governance", rationale: "Core layer because governance logic (draft\u2192publish workflows, consent-based decisions, tension status rules) is business process that multiple UIs consume. Why not Features? Because the versioning system and proposal flow are reusable engines \u2014 the Governance Pages in Features are just one rendering of these rules." } },
   { entryId: "ARCH-node-chainwork-engine", name: "ChainWork Engine", order: 3, data: { archType: "node", layerRef: "ARCH-layer-core", color: "#8b5cf6", icon: "\u26D3", description: "Guided strategy creation through 5-step coherence chain \u2014 AI-generated artifacts with scoring and achievements", filePaths: "src/lib/components/chainwork/config.ts, src/lib/components/chainwork/scoring.ts", owner: "ChainWork", rationale: "Core layer because the coherence chain logic, scoring algorithm, and quality gates are business rules. config.ts defines chain steps, scoring.ts computes quality \u2014 these could power a CLI or API. Why not Features? Because the ChainWork UI wizard in Features is just one skin over this engine." } },
@@ -2246,7 +2043,7 @@ var SEED_NODES = [
   { entryId: "ARCH-node-linear", name: "Linear (planned)", order: 2, data: { archType: "node", layerRef: "ARCH-layer-integration", color: "#f59e0b", icon: "\u{1F4D0}", description: "Issue tracking, roadmap sync, tension-to-issue pipeline (planned integration)", owner: "Platform", rationale: "Integration layer because Linear is an external issue tracker. Why not Infrastructure? Because Infra is generic plumbing we run. Linear is a third-party tool we connect to. The planned pipeline bridges tensions (Core) to Linear issues \u2014 a classic outward integration pattern." } }
 ];
 var SEED_FLOWS = [
-  { entryId: "ARCH-flow-smart-capture", name: "Smart Capture Flow", order: 0, data: { archType: "flow", sourceNode: "ARCH-node-cursor", targetNode: "ARCH-node-knowledge-graph", description: "Developer/AI calls smart-capture via MCP \u2192 entry created with auto-linking and quality score \u2192 stored in Knowledge Graph", color: "#8b5cf6" } },
+  { entryId: "ARCH-flow-smart-capture", name: "Capture Flow", order: 0, data: { archType: "flow", sourceNode: "ARCH-node-cursor", targetNode: "ARCH-node-knowledge-graph", description: "Developer/AI calls capture via MCP \u2192 entry created with auto-linking and quality score \u2192 stored in Knowledge Graph", color: "#8b5cf6" } },
   { entryId: "ARCH-flow-governance", name: "Governance Flow", order: 1, data: { archType: "flow", sourceNode: "ARCH-node-tensions", targetNode: "ARCH-node-governance", description: "Tension raised \u2192 appears in Command Center \u2192 triaged \u2192 processed via IDM \u2192 decision logged", color: "#6366f1" } },
   { entryId: "ARCH-flow-chainwork", name: "ChainWork Strategy Flow", order: 2, data: { archType: "flow", sourceNode: "ARCH-node-chainwork-ui", targetNode: "ARCH-node-artifacts", description: "Leader opens ChainWork \u2192 walks coherence chain \u2192 AI generates artifact \u2192 scored and published to knowledge graph", color: "#f59e0b" } },
   { entryId: "ARCH-flow-knowledge-trust", name: "Knowledge Trust Flow", order: 3, data: { archType: "flow", sourceNode: "ARCH-node-mcp", targetNode: "ARCH-node-glossary", description: "MCP verify tool checks entries against codebase \u2192 file existence, schema references validated \u2192 trust scores updated", color: "#22c55e" } },
@@ -2254,247 +2051,208 @@ var SEED_FLOWS = [
 ];
 function registerArchitectureTools(server2) {
   server2.registerTool(
-    "show-architecture",
+    "architecture",
     {
-      title: "Show Architecture",
-      description: "Render the system architecture map \u2014 layered visualization showing where every component lives. Returns layers (Auth \u2192 Infrastructure \u2192 Core \u2192 Features \u2192 Integration) with component nodes and data flows. Optionally filter by a specific template.",
+      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: {
-        template: z6.string().optional().describe("Template entry ID to filter by (default: first available template)")
+        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'")
       },
       annotations: { readOnlyHint: true }
     },
-    async ({ template }) => {
+    async ({ action, template, layer, flow }) => {
       await ensureCollection();
       const all = await listArchEntries();
-      const templates = byTag(all, "template");
-      const activeTemplate = template ? templates.find((t) => t.entryId === template) : templates[0];
-      const templateName = activeTemplate?.name ?? "System Architecture";
-      const templateId = activeTemplate?.entryId;
-      const layers = byTag(all, "layer").filter((l) => !templateId || l.data?.templateRef === templateId);
-      const nodes = byTag(all, "node");
-      const flows = byTag(all, "flow");
-      if (layers.length === 0) {
-        return {
-          content: [{
-            type: "text",
-            text: "# Architecture Explorer\n\nNo architecture data found. Use `seed-architecture` to populate the default Product OS architecture."
-          }]
-        };
-      }
-      const textLayers = layers.map((l) => formatLayerText(l, nodes)).join("\n\n");
-      const textFlows = flows.length > 0 ? "\n\n---\n\n## Data Flows\n\n" + flows.map(
-        (f) => `- **${f.name}**: ${f.data?.description ?? ""}`
-      ).join("\n") : "";
-      const text = `# ${templateName}
+      if (action === "show") {
+        const templates = byTag(all, "template");
+        const activeTemplate = template ? templates.find((t) => t.entryId === template) : templates[0];
+        const templateName = activeTemplate?.name ?? "System Architecture";
+        const templateId = activeTemplate?.entryId;
+        const layers = byTag(all, "layer").filter((l) => !templateId || l.data?.templateRef === templateId);
+        const nodes = byTag(all, "node");
+        const flows = byTag(all, "flow");
+        if (layers.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: "# Architecture Explorer\n\nNo architecture data found. Use `architecture-admin action=seed` to populate the default architecture."
+            }]
+          };
+        }
+        const textLayers = layers.map((l) => formatLayerText(l, nodes)).join("\n\n");
+        const textFlows = flows.length > 0 ? "\n\n---\n\n## Data Flows\n\n" + flows.map(
+          (f) => `- **${f.name}**: ${f.data?.description ?? ""}`
+        ).join("\n") : "";
+        const text = `# ${templateName}
 
 ${textLayers}${textFlows}`;
-      const html = renderArchitectureHtml(layers, nodes, flows, templateName);
-      return {
-        content: [
-          { type: "text", text },
-          { type: "resource", resource: { uri: `ui://product-os/architecture`, mimeType: "text/html", text: html } }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "explore-layer",
-    {
-      title: "Explore Architecture Layer",
-      description: "Drill into a specific architecture layer to see all its component nodes with descriptions, team ownership, file paths, and linked entry counts.",
-      inputSchema: {
-        layer: z6.string().describe("Layer name or entry ID, e.g. 'Core' or 'ARCH-layer-core'")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ layer }) => {
-      await ensureCollection();
-      const all = await listArchEntries();
-      const layers = byTag(all, "layer");
-      const target = layers.find(
-        (l) => l.name.toLowerCase() === layer.toLowerCase() || l.entryId === layer
-      );
-      if (!target) {
-        const available = layers.map((l) => `\`${l.name}\``).join(", ");
+        const html = renderArchitectureHtml(layers, nodes, flows, templateName);
         return {
-          content: [{
-            type: "text",
-            text: `Layer "${layer}" not found. Available layers: ${available}`
-          }]
+          content: [
+            { type: "text", text },
+            { type: "resource", resource: { uri: `ui://product-os/architecture`, mimeType: "text/html", text: html } }
+          ]
         };
       }
-      const nodes = byTag(all, "node").filter((n) => n.data?.layerRef === target.entryId);
-      const flows = byTag(all, "flow").filter(
-        (f) => nodes.some((n) => n.entryId === f.data?.sourceNode || n.entryId === f.data?.targetNode)
-      );
-      const depRule = target.data?.dependsOn ? `
+      if (action === "explore") {
+        if (!layer) return { content: [{ type: "text", text: "A `layer` is required for explore." }] };
+        const layers = byTag(all, "layer");
+        const target = layers.find(
+          (l) => l.name.toLowerCase() === layer.toLowerCase() || l.entryId === layer
+        );
+        if (!target) {
+          const available = layers.map((l) => `\`${l.name}\``).join(", ");
+          return { content: [{ type: "text", text: `Layer "${layer}" not found. Available layers: ${available}` }] };
+        }
+        const nodes = byTag(all, "node").filter((n) => n.data?.layerRef === target.entryId);
+        const flows = byTag(all, "flow").filter(
+          (f) => nodes.some((n) => n.entryId === f.data?.sourceNode || n.entryId === f.data?.targetNode)
+        );
+        const depRule = target.data?.dependsOn ? `
 **Dependency rule:** May import from ${target.data.dependsOn === "none" ? "nothing (foundation layer)" : target.data.dependsOn}.
 ` : "";
-      const layerRationale = target.data?.rationale ? `
+        const layerRationale = target.data?.rationale ? `
 > ${target.data.rationale}
 ` : "";
-      const nodeDetail = nodes.map((n) => {
-        const lines = [`#### ${n.data?.icon ?? "\u25FB"} ${n.name}`];
-        if (n.data?.description) lines.push(String(n.data.description));
-        if (n.data?.owner) lines.push(`**Owner:** ${n.data.owner}`);
-        if (n.data?.filePaths) lines.push(`**Files:** \`${n.data.filePaths}\``);
-        if (n.data?.rationale) lines.push(`
+        const nodeDetail = nodes.map((n) => {
+          const lines = [`#### ${n.data?.icon ?? "\u25FB"} ${n.name}`];
+          if (n.data?.description) lines.push(String(n.data.description));
+          if (n.data?.owner) lines.push(`**Owner:** ${n.data.owner}`);
+          if (n.data?.filePaths) lines.push(`**Files:** \`${n.data.filePaths}\``);
+          if (n.data?.rationale) lines.push(`
 **Why here?** ${n.data.rationale}`);
-        return lines.join("\n");
-      }).join("\n\n");
-      const flowLines = flows.length > 0 ? "\n\n### Connected Flows\n\n" + flows.map((f) => `- ${f.name}: ${f.data?.description ?? ""}`).join("\n") : "";
-      return {
-        content: [{
-          type: "text",
-          text: `# ${target.data?.icon ?? ""} ${target.name} Layer
+          return lines.join("\n");
+        }).join("\n\n");
+        const flowLines = flows.length > 0 ? "\n\n### Connected Flows\n\n" + flows.map((f) => `- ${f.name}: ${f.data?.description ?? ""}`).join("\n") : "";
+        return {
+          content: [{
+            type: "text",
+            text: `# ${target.data?.icon ?? ""} ${target.name} Layer
 
 ${target.data?.description ?? ""}${depRule}${layerRationale}
 **${nodes.length} components**
 
 ${nodeDetail}${flowLines}`
-        }]
-      };
-    }
-  );
-  server2.registerTool(
-    "show-flow",
-    {
-      title: "Show Architecture Flow",
-      description: "Visualize a specific data flow path between architecture nodes \u2014 shows source, target, and description.",
-      inputSchema: {
-        flow: z6.string().describe("Flow name or entry ID, e.g. 'Smart Capture Flow' or 'ARCH-flow-smart-capture'")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ flow }) => {
-      await ensureCollection();
-      const all = await listArchEntries();
-      const flows = byTag(all, "flow");
-      const target = flows.find(
-        (f) => f.name.toLowerCase() === flow.toLowerCase() || f.entryId === flow
-      );
-      if (!target) {
-        const available = flows.map((f) => `\`${f.name}\``).join(", ");
-        return {
-          content: [{
-            type: "text",
-            text: `Flow "${flow}" not found. Available flows: ${available}`
           }]
         };
       }
-      const nodes = byTag(all, "node");
-      const source = nodes.find((n) => n.entryId === target.data?.sourceNode);
-      const dest = nodes.find((n) => n.entryId === target.data?.targetNode);
-      const lines = [
-        `# ${target.name}`,
-        "",
-        `**${source?.data?.icon ?? "?"} ${source?.name ?? "Unknown"}** \u2192 **${dest?.data?.icon ?? "?"} ${dest?.name ?? "Unknown"}**`,
-        "",
-        String(target.data?.description ?? "")
-      ];
-      if (source) {
-        lines.push("", `### Source: ${source.name}`, String(source.data?.description ?? ""));
-        if (source.data?.filePaths) lines.push(`Files: \`${source.data.filePaths}\``);
-      }
-      if (dest) {
-        lines.push("", `### Target: ${dest.name}`, String(dest.data?.description ?? ""));
-        if (dest.data?.filePaths) lines.push(`Files: \`${dest.data.filePaths}\``);
+      if (action === "flow") {
+        if (!flow) return { content: [{ type: "text", text: "A `flow` name or entry ID is required." }] };
+        const flows = byTag(all, "flow");
+        const target = flows.find(
+          (f) => f.name.toLowerCase() === flow.toLowerCase() || f.entryId === flow
+        );
+        if (!target) {
+          const available = flows.map((f) => `\`${f.name}\``).join(", ");
+          return { content: [{ type: "text", text: `Flow "${flow}" not found. Available flows: ${available}` }] };
+        }
+        const nodes = byTag(all, "node");
+        const source = nodes.find((n) => n.entryId === target.data?.sourceNode);
+        const dest = nodes.find((n) => n.entryId === target.data?.targetNode);
+        const lines = [
+          `# ${target.name}`,
+          "",
+          `**${source?.data?.icon ?? "?"} ${source?.name ?? "Unknown"}** \u2192 **${dest?.data?.icon ?? "?"} ${dest?.name ?? "Unknown"}**`,
+          "",
+          String(target.data?.description ?? "")
+        ];
+        if (source) {
+          lines.push("", `### Source: ${source.name}`, String(source.data?.description ?? ""));
+          if (source.data?.filePaths) lines.push(`Files: \`${source.data.filePaths}\``);
+        }
+        if (dest) {
+          lines.push("", `### Target: ${dest.name}`, String(dest.data?.description ?? ""));
+          if (dest.data?.filePaths) lines.push(`Files: \`${dest.data.filePaths}\``);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
       }
-      return { content: [{ type: "text", text: lines.join("\n") }] };
+      return { content: [{ type: "text", text: "Unknown action." }] };
     }
   );
   server2.registerTool(
-    "seed-architecture",
+    "architecture-admin",
     {
-      title: "Seed Architecture Data",
-      description: "Populate the architecture collection with the default Product OS architecture map. Creates the template, layers, nodes, and flows. Safe to re-run \u2014 skips existing entries.",
-      annotations: { readOnlyHint: false }
+      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")
+      }
     },
-    async () => {
-      await ensureCollection();
-      const existing = await listArchEntries();
-      const existingIds = new Set(existing.map((e) => e.entryId));
-      let created = 0;
-      let updated = 0;
-      let unchanged = 0;
-      const allSeeds = [
-        { ...SEED_TEMPLATE, order: 0, status: "active" },
-        ...SEED_LAYERS.map((l) => ({ ...l, status: "active" })),
-        ...SEED_NODES.map((n) => ({ ...n, status: "active" })),
-        ...SEED_FLOWS.map((f) => ({ ...f, status: "active" }))
-      ];
-      for (const seed of allSeeds) {
-        if (existingIds.has(seed.entryId)) {
-          const existingEntry = existing.find((e) => e.entryId === seed.entryId);
-          const existingData = existingEntry?.data ?? {};
-          const seedData = seed.data;
-          const hasChanges = Object.keys(seedData).some(
-            (k) => seedData[k] !== void 0 && existingData[k] !== seedData[k]
-          );
-          if (hasChanges) {
-            const mergedData = { ...existingData, ...seedData };
-            await mcpMutation("kb.updateEntry", {
-              entryId: seed.entryId,
-              data: mergedData
-            });
-            updated++;
-          } else {
-            unchanged++;
+    async ({ action }) => {
+      if (action === "seed") {
+        await ensureCollection();
+        const existing = await listArchEntries();
+        const existingIds = new Set(existing.map((e) => e.entryId));
+        let created = 0;
+        let updated = 0;
+        let unchanged = 0;
+        const allSeeds = [
+          { ...SEED_TEMPLATE, order: 0, status: "active" },
+          ...SEED_LAYERS.map((l) => ({ ...l, status: "active" })),
+          ...SEED_NODES.map((n) => ({ ...n, status: "active" })),
+          ...SEED_FLOWS.map((f) => ({ ...f, status: "active" }))
+        ];
+        for (const seed of allSeeds) {
+          if (existingIds.has(seed.entryId)) {
+            const existingEntry = existing.find((e) => e.entryId === seed.entryId);
+            const existingData = existingEntry?.data ?? {};
+            const seedData = seed.data;
+            const hasChanges = Object.keys(seedData).some(
+              (k) => seedData[k] !== void 0 && existingData[k] !== seedData[k]
+            );
+            if (hasChanges) {
+              const mergedData = { ...existingData, ...seedData };
+              await mcpMutation("kb.updateEntry", { entryId: seed.entryId, data: mergedData });
+              updated++;
+            } else {
+              unchanged++;
+            }
+            continue;
           }
-          continue;
+          await mcpMutation("kb.createEntry", {
+            collectionSlug: COLLECTION_SLUG,
+            entryId: seed.entryId,
+            name: seed.name,
+            status: seed.status,
+            data: seed.data,
+            order: seed.order ?? 0
+          });
+          created++;
         }
-        await mcpMutation("kb.createEntry", {
-          collectionSlug: COLLECTION_SLUG,
-          entryId: seed.entryId,
-          name: seed.name,
-          status: seed.status,
-          data: seed.data,
-          order: seed.order ?? 0
-        });
-        created++;
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `# Architecture Seeded
+        return {
+          content: [{
+            type: "text",
+            text: `# Architecture Seeded
 
 **Created:** ${created} entries
 **Updated:** ${updated} (merged new fields)
 **Unchanged:** ${unchanged}
 
-Use \`show-architecture\` to view the map.`
-        }]
-      };
-    }
-  );
-  server2.registerTool(
-    "check-architecture",
-    {
-      title: "Check Architecture Health",
-      description: "Scan the codebase for dependency direction violations. Reads architecture layers, nodes, and their file paths from the knowledge base, then parses TypeScript/Svelte imports and checks them against the layer dependency rules (Auth \u2190 Infra \u2190 Core \u2190 Features; Integration \u2192 Core only). Returns a structured violation report.",
-      annotations: { readOnlyHint: true }
-    },
-    async () => {
-      const projectRoot = resolveProjectRoot2();
-      if (!projectRoot) {
-        return {
-          content: [{
-            type: "text",
-            text: "# Scan Failed\n\nCannot find project root (looked for `convex/schema.ts` in cwd and parent). Set `WORKSPACE_PATH` env var to the absolute path of the Product OS project root."
+Use \`architecture action=show\` to view the map.`
           }]
         };
       }
-      await ensureCollection();
-      const all = await listArchEntries();
-      const layers = byTag(all, "layer");
-      const nodes = byTag(all, "node");
-      const result = scanDependencies(projectRoot, layers, nodes);
-      return {
-        content: [{
-          type: "text",
-          text: formatScanReport(result)
-        }]
-      };
+      if (action === "check") {
+        const projectRoot = resolveProjectRoot2();
+        if (!projectRoot) {
+          return {
+            content: [{
+              type: "text",
+              text: "# Scan Failed\n\nCannot find project root (looked for `convex/schema.ts` in cwd and parent). Set `WORKSPACE_PATH` env var to the absolute path of the Product OS project root."
+            }]
+          };
+        }
+        await ensureCollection();
+        const all = await listArchEntries();
+        const layers = byTag(all, "layer");
+        const nodes = byTag(all, "node");
+        const result = scanDependencies(projectRoot, layers, nodes);
+        return { content: [{ type: "text", text: formatScanReport(result) }] };
+      }
+      return { content: [{ type: "text", text: "Unknown action." }] };
     }
   );
 }
@@ -2719,7 +2477,7 @@ import { z as z7 } from "zod";
 var RETRO_WORKFLOW = {
   id: "retro",
   name: "Retrospective",
-  shortDescription: "Structured team retrospective \u2014 reflect, surface patterns, commit to actions. Outputs a decision entry in the Knowledge Base.",
+  shortDescription: "Structured team retrospective \u2014 reflect, surface patterns, commit to actions. Commits a decision entry to the Chain.",
   icon: "\u25CE",
   facilitatorPreamble: `You are now in **Facilitator Mode**. You are not a coding assistant \u2014 you are a facilitator running a structured retrospective.
 
@@ -2731,7 +2489,7 @@ var RETRO_WORKFLOW = {
 4. **Create a Plan** at the start showing all rounds as tasks. Update it as you progress.
 5. **Synthesize between rounds.** After collecting input, reflect back what you heard before moving on.
 6. **Never go silent.** If something fails, say what happened and what to do next.
-7. **Capture to KB** at the end using the Product OS smart-capture tool.
+7. **Commit to the Chain** at the end using the Product OS capture tool.
 8. **Match the energy.** Be warm but structured. This is a ceremony, not a checklist.
 
 ## Communication Style
@@ -2855,7 +2613,7 @@ Create a Cursor Plan with these rounds as tasks. Mark each in_progress as you en
       label: "Close & Capture",
       type: "close",
       instruction: "One last thing \u2014 in one sentence, what's the single most important thing you're taking away from this retro?",
-      facilitatorGuidance: "Keep it brief. One sentence reflection. Then summarize the entire retro: scope, key wins, key pain points, patterns identified, actions committed. Ask if they want to save this to the Knowledge Base. If yes, use smart-capture to create a decision/tension entry. Thank them for the retro.",
+      facilitatorGuidance: "Keep it brief. One sentence reflection. Then summarize the entire retro: scope, key wins, key pain points, patterns identified, actions committed. Ask if they want to commit this to the Chain. If yes, use capture to create a decision/tension entry. Thank them for the retro.",
       outputSchema: {
         field: "takeaway",
         description: "Single-sentence takeaway",
@@ -2872,11 +2630,11 @@ Create a Cursor Plan with these rounds as tasks. Mark each in_progress as you en
   },
   errorRecovery: `If anything goes wrong during the retro:
 
-1. **MCP tool failure**: Skip the KB capture step. Summarize everything in the conversation instead. Suggest the participant runs \`smart-capture\` manually later.
+1. **MCP tool failure**: Skip the chain commit step. Summarize everything in the conversation instead. Suggest the participant runs \`capture\` manually later.
 2. **AskQuestion not available**: Fall back to numbered options in plain text. "Reply with 1, 2, or 3."
 3. **Plan creation fails**: Continue without the Plan. The conversation IS the record.
 4. **Participant goes off-topic**: Gently redirect: "That's valuable \u2014 let's capture it. For now, let's stay with [current round]."
-5. **Participant wants to stop**: Respect it. Summarize what you have so far. Offer to save partial results to KB.
+5. **Participant wants to stop**: Respect it. Summarize what you have so far. Offer to commit partial results to the Chain.
 
 The retro must never fail silently. Always communicate state.`
 };
@@ -2940,19 +2698,19 @@ ${cards}`
     "workflow-checkpoint",
     {
       title: "Workflow Checkpoint",
-      description: "Record the output of a workflow round. Captures the round's data to the Knowledge Base as a structured entry. Use this during Facilitator Mode after completing each round to persist progress \u2014 so if the conversation is interrupted, work is not lost.\n\nAt workflow completion, this tool can also generate the final summary entry.",
+      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(
-          "If true, this is the final checkpoint and triggers the summary KB entry creation"
+          "If true, this is the final checkpoint and triggers the summary chain entry creation"
         ),
         summaryName: z7.string().optional().describe(
-          "Name for the final KB entry (required when isFinal=true)"
+          "Name for the final chain entry (required when isFinal=true)"
         ),
         summaryDescription: z7.string().optional().describe(
-          "Full description/rationale for the final KB entry (required when isFinal=true)"
+          "Full description/rationale for the final chain entry (required when isFinal=true)"
         )
       },
       annotations: { destructiveHint: false }
@@ -3000,20 +2758,20 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
             createdBy: `workflow:${wf.id}`
           });
           lines.push(
-            `**KB Entry Created**: \`${entryId}\``,
+            `**Entry Committed**: \`${entryId}\``,
             `Collection: \`${wf.kbOutputCollection}\``,
             `Name: ${summaryName}`,
             "",
-            `The retro is now captured in the Knowledge Base. `,
+            `The retro is now committed to the Chain. `,
             `Use \`suggest-links\` on this entry to connect it to related knowledge.`
           );
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           lines.push(
-            `**KB capture failed**: ${msg}`,
+            `**Chain commit failed**: ${msg}`,
             "",
             `The retro output is preserved in this conversation. `,
-            `You can manually create the entry later using \`smart-capture\` with:`,
+            `You can manually create the entry later using \`capture\` with:`,
             `- Collection: \`${wf.kbOutputCollection}\``,
             `- Name: ${summaryName}`,
             `- Description: (copy from the conversation summary above)`
@@ -3035,7 +2793,7 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
         } else {
           lines.push(
             "",
-            `**All rounds complete.** Call this tool again with \`isFinal: true\` to create the KB entry.`
+            `**All rounds complete.** Call this tool again with \`isFinal: true\` to commit to the Chain.`
           );
         }
       }
@@ -3055,68 +2813,57 @@ function linkSummary(links) {
 }
 function registerGitChainTools(server2) {
   server2.registerTool(
-    "chain-create",
+    "chain",
     {
-      title: "Create Chain",
-      description: "Create a new strategic chain in the knowledge base. Chains are versioned knowledge artifacts that follow a chain type definition (e.g. Strategy Coherence: Problem \u2192 Insight \u2192 Choice \u2192 Action \u2192 Outcome). Returns the chain's entry ID for subsequent operations.",
+      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: {
-        title: z8.string().describe("Title for the chain, e.g. 'Q1 Growth Strategy'"),
-        chainTypeId: z8.string().default("strategy-coherence").describe(
-          "Chain type ID. Use 'strategy-coherence' for 5-link strategy chains (Problem \u2192 Insight \u2192 Choice \u2192 Action \u2192 Outcome) or 'idm-proposal' for IDM governance chains (Tension \u2192 Proposal \u2192 Objections \u2192 Integration \u2192 Decision)"
-        ),
-        description: z8.string().optional().describe("Optional description of what this chain is about"),
-        author: z8.string().optional().describe("Who is creating this chain (clerkUserId or person name). Defaults to 'mcp'.")
+        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'.")
       }
     },
-    async ({ title, chainTypeId, description, author }) => {
-      const result = await mcpMutation(
-        "gitchain.createChain",
-        { title, chainTypeId, description, author }
-      );
-      return {
-        content: [
-          {
+    async ({ action, chainEntryId, title, chainTypeId, description, linkId, content, status, author }) => {
+      if (action === "create") {
+        if (!title) return { content: [{ type: "text", text: "A `title` is required to create a process." }] };
+        const result = await mcpMutation(
+          "gitchain.createChain",
+          { title, chainTypeId, description, author }
+        );
+        return {
+          content: [{
             type: "text",
-            text: `# Chain Created
+            text: `# Process Created
 
 - **Entry ID:** \`${result.entryId}\`
 - **Title:** ${title}
 - **Type:** ${chainTypeId}
 - **Status:** draft
 
-Use \`chain-edit\` with chainEntryId=\`${result.entryId}\` to start filling in links.`
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-get",
-    {
-      title: "Get Chain",
-      description: "Retrieve a chain by its entry ID. Returns the full chain content, coherence scores, link fill status, and version info. Use chain-list first to discover chain entry IDs.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ chainEntryId }) => {
-      const chain = await mcpQuery("gitchain.getChain", { chainEntryId });
-      if (!chain) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Chain "${chainEntryId}" not found.`
-            }
-          ]
+Use \`chain action=edit chainEntryId="${result.entryId}" linkId="problem" content="..."\` to start filling in links.`
+          }]
         };
       }
-      const scoreSection = chain.scores ? `
+      if (action === "get") {
+        if (!chainEntryId) return { content: [{ type: "text", text: "A `chainEntryId` is required." }] };
+        const chain = await mcpQuery("gitchain.getChain", { chainEntryId });
+        if (!chain) {
+          return { content: [{ type: "text", text: `Process "${chainEntryId}" not found.` }] };
+        }
+        const scoreSection = chain.scores ? `
 ## Coherence: ${chain.coherenceScore}%
 
 ` + chain.scores.sections.map((s) => `- **${s.key}**: ${s.power}/100 (${"\u2605".repeat(Math.min(s.stars ?? 0, 5))}${"\u2606".repeat(Math.max(0, 5 - (s.stars ?? 0)))})`).join("\n") : "";
-      const text = `# ${chain.name}
+        return {
+          content: [{
+            type: "text",
+            text: `# ${chain.name}
 
 - **Entry ID:** \`${chain.entryId}\`
 - **Type:** ${chain.chainTypeName}
@@ -3129,29 +2876,32 @@ Use \`chain-edit\` with chainEntryId=\`${result.entryId}\` to start filling in l
 
 ## Links
 
-` + linkSummary(chain.links);
-      return { content: [{ type: "text", text }] };
-    }
-  );
-  server2.registerTool(
-    "chain-edit",
-    {
-      title: "Edit Chain Link",
-      description: "Edit a specific link in a chain. Each chain has named links (e.g. for strategy-coherence: problem, insight, choice, action, outcome). The link content is replaced entirely \u2014 pass the full new text.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
-        linkId: z8.string().describe(
-          "Which link to edit. For strategy-coherence: problem, insight, choice, action, outcome. For idm-proposal: tension, proposal, objections, integration, decision."
-        ),
-        content: z8.string().describe("The full new content for this link"),
-        author: z8.string().optional().describe("Who is making this edit. Defaults to 'mcp'.")
+` + linkSummary(chain.links)
+          }]
+        };
       }
-    },
-    async ({ chainEntryId, linkId, content, author }) => {
-      const result = await mcpMutation("gitchain.editLink", { chainEntryId, linkId, content, author });
-      return {
-        content: [
-          {
+      if (action === "list") {
+        const chains = await mcpQuery("gitchain.listChains", {
+          chainTypeId,
+          status
+        });
+        if (chains.length === 0) {
+          return { content: [{ type: "text", text: "No processes found. Use `chain action=create` to create one." }] };
+        }
+        const formatted = chains.map(
+          (c) => `- **\`${c.entryId}\`** ${c.name} \u2014 ${c.chainTypeId} \xB7 ${c.filledCount}/${c.totalCount} links \xB7 coherence: ${c.coherenceScore}% \xB7 status: ${c.status}`
+        ).join("\n");
+        return { content: [{ type: "text", text: `# Chains (${chains.length})
+
+${formatted}` }] };
+      }
+      if (action === "edit") {
+        if (!chainEntryId) return { content: [{ type: "text", text: "A `chainEntryId` is required." }] };
+        if (!linkId) return { content: [{ type: "text", text: "A `linkId` is required (e.g. problem, insight, choice, action, outcome)." }] };
+        if (!content) return { content: [{ type: "text", text: "The `content` for the link is required." }] };
+        const result = await mcpMutation("gitchain.editLink", { chainEntryId, linkId, content, author });
+        return {
+          content: [{
             type: "text",
             text: `# Link Updated
 
@@ -3160,114 +2910,38 @@ Use \`chain-edit\` with chainEntryId=\`${result.entryId}\` to start filling in l
 - **Chain status:** ${result.status}
 - **Content length:** ${content.length} chars
 
-Use \`chain-get\` to see the full chain with updated scores.`
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-list",
-    {
-      title: "List Chains",
-      description: "List all chains in the workspace, optionally filtered by chain type or status. Returns entry IDs, titles, link fill progress, and coherence scores.",
-      inputSchema: {
-        chainTypeId: z8.string().optional().describe("Filter by chain type: 'strategy-coherence' or 'idm-proposal'"),
-        status: z8.string().optional().describe("Filter by status: 'draft' or 'active'")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ chainTypeId, status }) => {
-      const chains = await mcpQuery("gitchain.listChains", {
-        chainTypeId,
-        status
-      });
-      if (chains.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "No chains found. Use `chain-create` to create one."
-            }
-          ]
+Use \`chain action=get\` to see the full chain with updated scores.`
+          }]
         };
       }
-      const formatted = chains.map(
-        (c) => `- **\`${c.entryId}\`** ${c.name} \u2014 ${c.chainTypeId} \xB7 ${c.filledCount}/${c.totalCount} links \xB7 coherence: ${c.coherenceScore}% \xB7 status: ${c.status}`
-      ).join("\n");
-      return {
-        content: [
-          {
-            type: "text",
-            text: `# Chains (${chains.length})
-
-${formatted}`
-          }
-        ]
-      };
+      return { content: [{ type: "text", text: "Unknown action." }] };
     }
   );
   server2.registerTool(
-    "chain-history",
+    "chain-version",
     {
-      title: "Chain History",
-      description: "View the edit history of a chain \u2014 all creation, update, and version events. Shows who changed what and when.",
+      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: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'")
+        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'.")
       },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ chainEntryId }) => {
-      const history = await mcpQuery("gitchain.getHistory", {
-        chainEntryId
-      });
-      if (history.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No history found for chain "${chainEntryId}".`
-            }
-          ]
-        };
-      }
-      const formatted = history.sort((a, b) => b.timestamp - a.timestamp).map((h) => {
-        const date = new Date(h.timestamp).toISOString().replace("T", " ").substring(0, 19);
-        return `- **${date}** [${h.event}] by ${h.changedBy ?? "unknown"} \u2014 ${h.note ?? ""}`;
-      }).join("\n");
-      return {
-        content: [
-          {
-            type: "text",
-            text: `# History for ${chainEntryId} (${history.length} events)
-
-${formatted}`
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-commit",
-    {
-      title: "Commit Chain",
-      description: "Create a version snapshot (commit) of the current chain state. Records all link content, computes coherence score, and tracks which links changed. Commit messages should follow: type(link): description. Types: edit, refine, rewrite, integrate, revert.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
-        commitMessage: z8.string().describe(
-          "Commit message following convention: type(link): description. Example: 'edit(outcome): Add Q1 revenue target'"
-        ),
-        author: z8.string().optional().describe("Who is committing. Defaults to 'mcp'.")
-      }
+      annotations: { readOnlyHint: false }
     },
-    async ({ chainEntryId, commitMessage, author }) => {
-      const result = await mcpMutation("gitchain.commitChain", { chainEntryId, commitMessage, author });
-      const warning = result.commitLintWarning ? `
+    async ({ action, chainEntryId, commitMessage, versionA, versionB, toVersion, author }) => {
+      if (action === "commit") {
+        if (!commitMessage) return { content: [{ type: "text", text: "A `commitMessage` is required." }] };
+        const result = await mcpMutation("gitchain.commitChain", { chainEntryId, commitMessage, author });
+        const warning = result.commitLintWarning ? `
 
 > **Lint warning:** ${result.commitLintWarning}` : "";
-      return {
-        content: [
-          {
+        return {
+          content: [{
             type: "text",
             text: `# Committed v${result.version}
 
@@ -3277,229 +2951,160 @@ ${formatted}`
 - **Coherence:** ${result.coherenceScore}%
 - **Links modified:** ${result.linksModified.length > 0 ? result.linksModified.join(", ") : "none"}
 ` + warning
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-commits",
-    {
-      title: "List Chain Commits",
-      description: "List all version snapshots (commits) for a chain, newest first. Shows version number, commit message, author, which links were modified, and status.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ chainEntryId }) => {
-      const commits = await mcpQuery("gitchain.listCommits", {
-        chainEntryId
-      });
-      if (commits.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No commits found for chain "${chainEntryId}". Use \`chain-commit\` to create the first snapshot.`
-            }
-          ]
+          }]
         };
       }
-      const formatted = commits.map((c) => {
-        const date = new Date(c.createdAt).toISOString().replace("T", " ").substring(0, 19);
-        const msg = c.commitMessage ?? c.changeNote ?? "(no message)";
-        const links = c.linksModified && c.linksModified.length > 0 ? ` [${c.linksModified.join(", ")}]` : "";
-        return `- **v${c.version}** ${date} by ${c.author} \u2014 ${msg}${links} (${c.versionStatus})`;
-      }).join("\n");
-      return {
-        content: [
-          {
-            type: "text",
-            text: `# Commits for ${chainEntryId} (${commits.length})
-
-${formatted}`
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-diff",
-    {
-      title: "Diff Chain Versions",
-      description: "Compare two versions of a chain. Shows which links changed, word-level diffs for modified links, and the coherence score delta. Use chain-commits first to see available version numbers.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
-        versionA: z8.number().describe("The earlier version number"),
-        versionB: z8.number().describe("The later version number")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ chainEntryId, versionA, versionB }) => {
-      const diff = await mcpMutation("gitchain.diffVersions", {
-        chainEntryId,
-        versionA,
-        versionB
-      });
-      let text = `# Diff: v${versionA} \u2192 v${versionB}
+      if (action === "list") {
+        const commits = await mcpQuery("gitchain.listCommits", { chainEntryId });
+        if (commits.length === 0) {
+          return { content: [{ type: "text", text: `No commits found for chain "${chainEntryId}". Use \`chain-version action=commit\` to create the first snapshot.` }] };
+        }
+        const formatted = commits.map((c) => {
+          const date = new Date(c.createdAt).toISOString().replace("T", " ").substring(0, 19);
+          const msg = c.commitMessage ?? c.changeNote ?? "(no message)";
+          const links = c.linksModified?.length > 0 ? ` [${c.linksModified.join(", ")}]` : "";
+          return `- **v${c.version}** ${date} by ${c.author} \u2014 ${msg}${links} (${c.versionStatus})`;
+        }).join("\n");
+        return { content: [{ type: "text", text: `# Commits for ${chainEntryId} (${commits.length})
+
+${formatted}` }] };
+      }
+      if (action === "diff") {
+        if (versionA == null || versionB == null) {
+          return { content: [{ type: "text", text: "Both `versionA` and `versionB` are required for diff." }] };
+        }
+        const diff = await mcpMutation("gitchain.diffVersions", { chainEntryId, versionA, versionB });
+        let text = `# Diff: v${versionA} \u2192 v${versionB}
 
 - **Chain:** \`${diff.chainEntryId}\`
 - **Coherence:** ${diff.coherenceBefore}% \u2192 ${diff.coherenceAfter}% (${diff.coherenceDelta >= 0 ? "+" : ""}${diff.coherenceDelta})
 - **Links changed:** ${diff.linksChanged.length > 0 ? diff.linksChanged.join(", ") : "none"}
 `;
-      for (const ld of diff.linkDiffs) {
-        if (ld.status === "unchanged") continue;
-        text += `
+        for (const ld of diff.linkDiffs) {
+          if (ld.status === "unchanged") continue;
+          text += `
 ## ${ld.linkId} (${ld.status})
 
 `;
-        const wordDiff = diff.wordDiffs[ld.linkId];
-        if (wordDiff && wordDiff.length > 0) {
-          for (const w of wordDiff) {
-            if (w.type === "delete") {
-              text += `~~${w.value.substring(0, 200)}~~`;
-            } else if (w.type === "insert") {
-              text += `**${w.value.substring(0, 200)}**`;
-            } else {
-              text += w.value.substring(0, 200);
+          const wordDiff = diff.wordDiffs[ld.linkId];
+          if (wordDiff?.length > 0) {
+            for (const w of wordDiff) {
+              if (w.type === "delete") text += `~~${w.value.substring(0, 200)}~~`;
+              else if (w.type === "insert") text += `**${w.value.substring(0, 200)}**`;
+              else text += w.value.substring(0, 200);
             }
+            text += "\n";
           }
-          text += "\n";
         }
+        return { content: [{ type: "text", text }] };
       }
-      return { content: [{ type: "text", text }] };
-    }
-  );
-  server2.registerTool(
-    "chain-gate",
-    {
-      title: "Chain Coherence Gate",
-      description: "Run the coherence gate on a chain. Checks: coherence score >= 70%, all links filled, commit message follows convention. Returns pass/fail with detailed check results. This is the same gate that blocks publishing.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
-        commitMessage: z8.string().optional().describe("Optional commit message to lint")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ chainEntryId, commitMessage }) => {
-      const gate = await mcpQuery("gitchain.runGate", {
-        chainEntryId,
-        commitMessage
-      });
-      const checkLines = gate.checks.map(
-        (c) => `- ${c.pass ? "PASS" : "FAIL"} **${c.name}**: ${c.detail}`
-      ).join("\n");
-      const icon = gate.pass ? "PASS" : "BLOCKED";
-      return {
-        content: [
-          {
+      if (action === "revert") {
+        if (toVersion == null) return { content: [{ type: "text", text: "A `toVersion` is required for revert." }] };
+        const result = await mcpMutation("gitchain.revertChain", { chainEntryId, toVersion, author });
+        return {
+          content: [{
             type: "text",
-            text: `# Gate: ${icon}
+            text: `# Reverted
 
-- **Score:** ${gate.score}%
-- **Threshold:** ${gate.threshold}%
+- **Chain:** \`${result.entryId}\`
+- **Reverted to:** v${result.revertedTo}
+- **New version:** v${result.newVersion}
+- **Links affected:** ${result.linksModified.length > 0 ? result.linksModified.join(", ") : "none"}
 
-## Checks
+History is preserved \u2014 this created a new version, not a destructive reset.`
+          }]
+        };
+      }
+      if (action === "history") {
+        const history = await mcpQuery("gitchain.getHistory", { chainEntryId });
+        if (history.length === 0) {
+          return { content: [{ type: "text", text: `No history found for chain "${chainEntryId}".` }] };
+        }
+        const formatted = history.sort((a, b) => b.timestamp - a.timestamp).map((h) => {
+          const date = new Date(h.timestamp).toISOString().replace("T", " ").substring(0, 19);
+          return `- **${date}** [${h.event}] by ${h.changedBy ?? "unknown"} \u2014 ${h.note ?? ""}`;
+        }).join("\n");
+        return { content: [{ type: "text", text: `# History for ${chainEntryId} (${history.length} events)
 
-${checkLines}`
-          }
-        ]
-      };
+${formatted}` }] };
+      }
+      return { content: [{ type: "text", text: "Unknown action." }] };
     }
   );
   server2.registerTool(
     "chain-branch",
     {
-      title: "Create or List Chain Branches",
-      description: "Create a new branch for isolated editing, or list all branches on a chain. Branches fork from the current published version of main. Use chain-merge to merge a branch back.",
+      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: {
-        chainEntryId: z8.string().describe("The chain's entry ID, e.g. 'CH-A1B2C3'"),
-        action: z8.enum(["create", "list"]).describe("'create' to make a new branch, 'list' to see all branches"),
-        name: z8.string().optional().describe("Branch name for 'create' action. Auto-generated if not provided."),
-        author: z8.string().optional().describe("Who is creating the branch. Defaults to 'mcp'.")
+        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'.")
       }
     },
-    async ({ chainEntryId, action, name, author }) => {
+    async ({ action, chainEntryId, branchName, strategy, author }) => {
       if (action === "create") {
-        const result = await mcpMutation("gitchain.createBranch", { chainEntryId, name, author });
+        const result = await mcpMutation("gitchain.createBranch", { chainEntryId, name: branchName, author });
         return {
-          content: [
-            {
-              type: "text",
-              text: `# Branch Created
+          content: [{
+            type: "text",
+            text: `# Branch Created
 
 - **Name:** ${result.name}
 - **Based on:** v${result.baseVersion}
 - **Chain:** \`${chainEntryId}\`
 
-Edit links and commit on this branch, then use \`chain-merge\` to land changes.`
-            }
-          ]
+Edit links and commit on this branch, then use \`chain-branch action=merge\` to land changes.`
+          }]
         };
       }
-      const branches = await mcpMutation("gitchain.listBranches", {
-        chainEntryId
-      });
-      if (branches.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No branches found for chain "${chainEntryId}".`
-            }
-          ]
-        };
+      if (action === "list") {
+        const branches = await mcpMutation("gitchain.listBranches", { chainEntryId });
+        if (branches.length === 0) {
+          return { content: [{ type: "text", text: `No branches found for chain "${chainEntryId}".` }] };
+        }
+        const formatted = branches.map((b) => `- **${b.name}** (${b.status}) \u2014 based on v${b.baseVersion}, by ${b.createdBy}`).join("\n");
+        return { content: [{ type: "text", text: `# Branches for ${chainEntryId} (${branches.length})
+
+${formatted}` }] };
       }
-      const formatted = branches.map(
-        (b) => `- **${b.name}** (${b.status}) \u2014 based on v${b.baseVersion}, by ${b.createdBy}`
-      ).join("\n");
-      return {
-        content: [
-          {
+      if (action === "merge") {
+        if (!branchName) return { content: [{ type: "text", text: "A `branchName` is required for merge." }] };
+        const result = await mcpMutation("gitchain.mergeBranch", { chainEntryId, branchName, strategy, author });
+        return {
+          content: [{
             type: "text",
-            text: `# Branches for ${chainEntryId} (${branches.length})
+            text: `# Branch Merged
 
-${formatted}`
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-conflicts",
-    {
-      title: "Check Branch Conflicts",
-      description: "Check if a branch has conflicts with other active branches. Conflicts occur when two branches modify the same chain link. Always check before merging.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID"),
-        branchName: z8.string().describe("The branch name to check for conflicts")
-      },
-      annotations: { readOnlyHint: true }
-    },
-    async ({ chainEntryId, branchName }) => {
-      const result = await mcpMutation("gitchain.checkConflicts", {
-        chainEntryId,
-        branchName
-      });
-      if (!result.hasConflicts) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `# No Conflicts
+- **Chain:** \`${result.entryId}\`
+- **Branch:** ${result.branchName} (now closed)
+- **Version:** v${result.version}
+- **Strategy:** ${result.strategy}
 
-Branch "${branchName}" on \`${chainEntryId}\` has no conflicts with other active branches. Safe to merge.`
-            }
-          ]
+Main is now at v${result.version}. The branch has been closed.`
+          }]
         };
       }
-      const conflictLines = result.conflicts.map(
-        (c) => `- **${c.linkId}** \u2014 modified by: ${c.branches.map((b) => `${b.branchName} (${b.author})`).join(", ")}`
-      ).join("\n");
-      return {
-        content: [
-          {
+      if (action === "conflicts") {
+        if (!branchName) return { content: [{ type: "text", text: "A `branchName` is required for conflict check." }] };
+        const result = await mcpMutation("gitchain.checkConflicts", { chainEntryId, branchName });
+        if (!result.hasConflicts) {
+          return {
+            content: [{
+              type: "text",
+              text: `# No Conflicts
+
+Branch "${branchName}" on \`${chainEntryId}\` has no conflicts. Safe to merge.`
+            }]
+          };
+        }
+        const conflictLines = result.conflicts.map(
+          (c) => `- **${c.linkId}** \u2014 modified by: ${c.branches.map((b) => `${b.branchName} (${b.author})`).join(", ")}`
+        ).join("\n");
+        return {
+          content: [{
             type: "text",
             text: `# Conflicts Detected
 
@@ -3507,67 +3112,52 @@ Branch "${branchName}" conflicts with other branches on these links:
 
 ` + conflictLines + `
 
-Resolve conflicts before merging. One branch must update its link content to avoid overwriting.`
-          }
-        ]
-      };
+Resolve conflicts before merging.`
+          }]
+        };
+      }
+      return { content: [{ type: "text", text: "Unknown action." }] };
     }
   );
   server2.registerTool(
-    "chain-merge",
+    "chain-review",
     {
-      title: "Merge Branch",
-      description: "Merge a branch back into main. Runs the coherence gate before merging. The branch is closed after merge. Check for conflicts with chain-conflicts first.",
+      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"),
-        branchName: z8.string().describe("The branch to merge"),
-        strategy: z8.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) preserves history, 'squash' collapses into one version"),
-        author: z8.string().optional().describe("Who is merging. Defaults to 'mcp'.")
-      }
+        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'.")
+      },
+      annotations: { readOnlyHint: false }
     },
-    async ({ chainEntryId, branchName, strategy, author }) => {
-      const result = await mcpMutation("gitchain.mergeBranch", {
-        chainEntryId,
-        branchName,
-        strategy,
-        author
-      });
-      return {
-        content: [
-          {
+    async ({ action, chainEntryId, commitMessage, versionNumber, linkId, body, commentId, author }) => {
+      if (action === "gate") {
+        const gate = await mcpQuery("gitchain.runGate", { chainEntryId, commitMessage });
+        const checkLines = gate.checks.map((c) => `- ${c.pass ? "PASS" : "FAIL"} **${c.name}**: ${c.detail}`).join("\n");
+        const icon = gate.pass ? "PASS" : "BLOCKED";
+        return {
+          content: [{
             type: "text",
-            text: `# Branch Merged
+            text: `# Gate: ${icon}
 
-- **Chain:** \`${result.entryId}\`
-- **Branch:** ${result.branchName} (now closed)
-- **Version:** v${result.version}
-- **Strategy:** ${result.strategy}
+- **Score:** ${gate.score}%
+- **Threshold:** ${gate.threshold}%
 
-Main is now at v${result.version}. The branch has been closed.`
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-comment",
-    {
-      title: "Comment on Chain Version",
-      description: "Add a threaded comment on a specific chain version, optionally targeting a specific link. Comments support threading via parentId. Use chain-comments to see existing comments.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID"),
-        action: z8.enum(["add", "resolve", "list"]).describe("'add' a comment, 'resolve' a comment, or 'list' all comments"),
-        versionNumber: z8.number().optional().describe("Version number to comment on (required for 'add')"),
-        linkId: z8.string().optional().describe("Which link this comment targets (optional)"),
-        body: z8.string().optional().describe("Comment text (required for 'add')"),
-        commentId: z8.string().optional().describe("Comment ID to resolve (required for 'resolve')"),
-        author: z8.string().optional().describe("Who is commenting. Defaults to 'mcp'.")
+## Checks
+
+${checkLines}`
+          }]
+        };
       }
-    },
-    async ({ chainEntryId, action, versionNumber, linkId, body, commentId, author }) => {
-      if (action === "add") {
-        if (!versionNumber) throw new Error("versionNumber is required for 'add'");
-        if (!body) throw new Error("body is required for 'add'");
+      if (action === "comment") {
+        if (!versionNumber) return { content: [{ type: "text", text: "A `versionNumber` is required." }] };
+        if (!body) return { content: [{ type: "text", text: "A `body` is required." }] };
         const result = await mcpMutation("gitchain.addComment", {
           chainEntryId,
           versionNumber,
@@ -3576,92 +3166,47 @@ Main is now at v${result.version}. The branch has been closed.`
           author
         });
         return {
-          content: [
-            {
-              type: "text",
-              text: `# Comment Added
+          content: [{
+            type: "text",
+            text: `# Comment Added
 
 - **Chain:** \`${result.chainEntryId}\`
 - **Version:** v${result.versionNumber}
 ` + (result.linkId ? `- **Link:** ${result.linkId}
-` : "") + `- **Body:** ${body?.substring(0, 200)}`
-            }
-          ]
+` : "") + `- **Body:** ${body.substring(0, 200)}`
+          }]
         };
       }
-      if (action === "resolve") {
-        if (!commentId) throw new Error("commentId is required for 'resolve'");
+      if (action === "resolve-comment") {
+        if (!commentId) return { content: [{ type: "text", text: "A `commentId` is required." }] };
         await mcpMutation("gitchain.resolveComment", { commentId });
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Comment resolved.`
-            }
-          ]
-        };
+        return { content: [{ type: "text", text: `Comment resolved.` }] };
       }
-      const comments = await mcpMutation("gitchain.listComments", {
-        chainEntryId,
-        versionNumber
-      });
-      if (comments.length === 0) {
+      if (action === "list-comments") {
+        const comments = await mcpMutation("gitchain.listComments", {
+          chainEntryId,
+          versionNumber
+        });
+        if (comments.length === 0) {
+          return { content: [{ type: "text", text: `No comments found for chain "${chainEntryId}"${versionNumber ? ` v${versionNumber}` : ""}.` }] };
+        }
+        const formatted = comments.map((c) => {
+          const date = new Date(c.createdAt).toISOString().replace("T", " ").substring(0, 19);
+          const resolved = c.resolved ? " (RESOLVED)" : "";
+          const link = c.linkId ? ` [${c.linkId}]` : "";
+          return `- **v${c.version}${link}** ${date} by ${c.author}${resolved}: ${c.body.substring(0, 150)}`;
+        }).join("\n");
+        const unresolvedCount = comments.filter((c) => !c.resolved).length;
         return {
-          content: [
-            {
-              type: "text",
-              text: `No comments found for chain "${chainEntryId}"${versionNumber ? ` v${versionNumber}` : ""}.`
-            }
-          ]
-        };
-      }
-      const formatted = comments.map((c) => {
-        const date = new Date(c.createdAt).toISOString().replace("T", " ").substring(0, 19);
-        const resolved = c.resolved ? " (RESOLVED)" : "";
-        const link = c.linkId ? ` [${c.linkId}]` : "";
-        return `- **v${c.version}${link}** ${date} by ${c.author}${resolved}: ${c.body.substring(0, 150)}`;
-      }).join("\n");
-      const unresolvedCount = comments.filter((c) => !c.resolved).length;
-      return {
-        content: [
-          {
+          content: [{
             type: "text",
             text: `# Comments for ${chainEntryId} (${comments.length}, ${unresolvedCount} unresolved)
 
 ${formatted}`
-          }
-        ]
-      };
-    }
-  );
-  server2.registerTool(
-    "chain-revert",
-    {
-      title: "Revert Chain",
-      description: "Safely revert a chain to a previous version. Creates a NEW version that restores the content of the target version \u2014 history is preserved, nothing is destroyed. Use chain-commits to see available versions.",
-      inputSchema: {
-        chainEntryId: z8.string().describe("The chain's entry ID"),
-        toVersion: z8.number().describe("The version number to revert to"),
-        author: z8.string().optional().describe("Who is reverting. Defaults to 'mcp'.")
+          }]
+        };
       }
-    },
-    async ({ chainEntryId, toVersion, author }) => {
-      const result = await mcpMutation("gitchain.revertChain", { chainEntryId, toVersion, author });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `# Reverted
-
-- **Chain:** \`${result.entryId}\`
-- **Reverted to:** v${result.revertedTo}
-- **New version:** v${result.newVersion}
-- **Links affected:** ${result.linksModified.length > 0 ? result.linksModified.join(", ") : "none"}
-
-History is preserved \u2014 this created a new version, not a destructive reset.`
-          }
-        ]
-      };
+      return { content: [{ type: "text", text: "Unknown action." }] };
     }
   );
 }
@@ -3706,7 +3251,7 @@ Tags for filtering (e.g. \`severity:high\`), relations via \`entryRelations\`, h
   sections.push(
     `## Business Rules
 Collection: \`business-rules\` (${rulesCount}).
-Find rules: \`kb-search\` for text search, \`list-entries collection=business-rules\` to browse.
+Find rules: \`search\` for text search, \`list-entries collection=business-rules\` to browse.
 Check compliance: use the \`review-against-rules\` prompt (pass a domain).
 Draft a new rule: use the \`draft-rule-from-context\` prompt.`
   );
@@ -3723,16 +3268,16 @@ Browse: \`list-entries collection=tracking-events\`. Full setup: \`docs/posthog-
     "## Knowledge Graph\nEntries are connected via typed relations (`entryRelations` table). Relations are bidirectional and collection-agnostic \u2014 any entry can link to any other entry.\n\n**Recommended relation types** (extensible \u2014 any string accepted):\n- `governs` \u2014 a rule constrains behavior of a feature\n- `defines_term_for` \u2014 a glossary term is canonical vocabulary for a feature/area\n- `belongs_to` \u2014 a feature belongs to a product area or parent concept\n- `informs` \u2014 a decision or insight informs a feature\n- `surfaces_tension_in` \u2014 a tension exists within a feature area\n- `related_to`, `depends_on`, `replaces`, `conflicts_with`, `references`, `confused_with`\n\nEach relation type is defined as a glossary entry (prefix `GT-REL-*`) to prevent terminology drift.\n\n**Tools:**\n- `gather-context` \u2014 get the full context around any entry (multi-hop graph traversal)\n- `suggest-links` \u2014 discover potential connections for an entry\n- `relate-entries` \u2014 create a typed link between two entries\n- `find-related` \u2014 list direct relations for an entry\n\n**Convention:** When creating or updating entries in governed collections, always use `suggest-links` to discover and create relevant relations."
   );
   sections.push(
-    "## Creating Knowledge\nUse `smart-capture` as the primary tool for creating new entries. It handles the full workflow in one call:\n1. Creates the entry with collection-aware defaults (auto-fills dates, infers domains, sets priority)\n2. Auto-links related entries from across the knowledge base (up to 5 confident matches)\n3. Returns a quality scorecard (X/10) with actionable improvement suggestions\n\n**Smart profiles** exist for: `tensions`, `business-rules`, `glossary`, `decisions`.\nAll other collections use sensible defaults.\n\nExample: `smart-capture collection='tensions' name='...' description='...'`\n\nUse `quality-check` to score existing entries retroactively.\nUse `create-entry` only when you need full control over every field.\nUse `quick-capture` for minimal ceremony without auto-linking."
+    "## 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."
   );
   sections.push(
-    "## Where to Go Next\n- **Create entry** \u2192 `smart-capture` tool (auto-links + quality score in one call)\n- **Full context** \u2192 `gather-context` tool (start here when working on a feature)\n- **Discover links** \u2192 `suggest-links` tool\n- **Quality audit** \u2192 `quality-check` tool\n- **Terminology** \u2192 `name-check` prompt or `productbrain://terminology` resource\n- **Schema details** \u2192 `productbrain://collections` resource or `list-collections` tool\n- **Labels** \u2192 `productbrain://labels` resource or `list-labels` tool\n- **Any collection** \u2192 `productbrain://{slug}/entries` resource\n- **Log a decision** \u2192 `draft-decision-record` prompt\n- **Architecture map** \u2192 `show-architecture` tool (layered system visualization)\n- **Explore a layer** \u2192 `explore-layer` tool (drill into Auth, Core, Features, etc.)\n- **Health check** \u2192 `health` tool\n- **Debug MCP calls** \u2192 `mcp-audit` tool"
+    "## 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"
   );
   return sections.join("\n\n---\n\n");
 }
 function registerResources(server2) {
   server2.resource(
-    "kb-orientation",
+    "chain-orientation",
     "productbrain://orientation",
     async (uri) => {
       const [collectionsResult, eventsResult, standardsResult, rulesResult] = await Promise.allSettled([
@@ -3755,7 +3300,7 @@ function registerResources(server2) {
     }
   );
   server2.resource(
-    "kb-terminology",
+    "chain-terminology",
     "productbrain://terminology",
     async (uri) => {
       const [glossaryResult, standardsResult] = await Promise.allSettled([
@@ -3770,7 +3315,7 @@ function registerResources(server2) {
 
 ${terms}`);
         } else {
-          lines.push("## Glossary\n\nNo glossary terms yet. Use `create-entry` with collection `glossary` to add terms.");
+          lines.push("## Glossary\n\nNo glossary terms yet. Use `capture` with collection `glossary` to add terms.");
         }
       } else {
         lines.push("## Glossary\n\nCould not load glossary \u2014 use `list-entries collection=glossary` to browse manually.");
@@ -3782,7 +3327,7 @@ ${terms}`);
 
 ${stds}`);
         } else {
-          lines.push("## Standards\n\nNo standards yet. Use `create-entry` with collection `standards` to add standards.");
+          lines.push("## Standards\n\nNo standards yet. Use `capture` with collection `standards` to add standards.");
         }
       } else {
         lines.push("## Standards\n\nCould not load standards \u2014 use `list-entries collection=standards` to browse manually.");
@@ -3793,7 +3338,7 @@ ${stds}`);
     }
   );
   server2.resource(
-    "kb-collections",
+    "chain-collections",
     "productbrain://collections",
     async (uri) => {
       const collections = await mcpQuery("kb.listCollections");
@@ -3816,7 +3361,7 @@ ${formatted}`, mimeType: "text/markdown" }]
     }
   );
   server2.resource(
-    "kb-collection-entries",
+    "chain-collection-entries",
     new ResourceTemplate("productbrain://{slug}/entries", {
       list: async () => {
         const collections = await mcpQuery("kb.listCollections");
@@ -3841,7 +3386,7 @@ ${formatted}`, mimeType: "text/markdown" }]
     }
   );
   server2.resource(
-    "kb-labels",
+    "chain-labels",
     "productbrain://labels",
     async (uri) => {
       const labels = await mcpQuery("kb.listLabels");
@@ -3995,7 +3540,7 @@ Structure the decision record with:
 6. **Alternatives considered**: What else was on the table
 7. **Related rules or tensions**: Any business rules or tensions this connects to
 
-After drafting, I can log it using the create-entry tool with collection "decisions".`
+After drafting, I can log it using the capture tool with collection "decisions".`
             }
           }
         ]
@@ -4041,7 +3586,7 @@ Draft the rule with these fields:
 7. **data.platforms**: Which platforms are affected
 8. **data.relatedRules**: Any related existing rules
 
-Make sure the rule is consistent with existing rules and doesn't contradict them. After drafting, I can create it using the create-entry tool with collection "business-rules".`
+Make sure the rule is consistent with existing rules and doesn't contradict them. After drafting, I can create it using the capture tool with collection "business-rules".`
             }
           }
         ]
@@ -4092,7 +3637,7 @@ Use one of these IDs to run a workflow.`
 ` + sorted.map((d) => `- ${d.entryId ?? ""}: ${d.name} [${d.status}]`).join("\n");
         }
       } catch {
-        kbContext = "\n_Could not load KB context \u2014 proceed without it._";
+        kbContext = "\n_Could not load chain context \u2014 proceed without it._";
       }
       const roundsPlan = wf.rounds.map(
         (r) => `### Round ${r.num}: ${r.label}
@@ -4139,9 +3684,9 @@ ${wf.errorRecovery}
 
 ---
 
-## KB Output
+## Chain Output
 
-When complete, use \`smart-capture\` to create a \`${wf.kbOutputCollection}\` entry.
+When complete, use \`capture\` to create a \`${wf.kbOutputCollection}\` entry.
 Name template: ${wf.kbOutputTemplate.nameTemplate}
 Description field: ${wf.kbOutputTemplate.descriptionField}
 ` + kbContext + `
@@ -4172,7 +3717,7 @@ if (!process.env.CONVEX_SITE_URL && !process.env.PRODUCTBRAIN_API_KEY) {
   }
 }
 bootstrapCloudMode();
-var SERVER_VERSION = "1.0.0";
+var SERVER_VERSION = "2.0.0";
 initAnalytics();
 var workspaceId;
 try {
@@ -4199,39 +3744,37 @@ var server = new McpServer2(
       "Product Brain \u2014 the single source of truth for product knowledge.",
       "Terminology, standards, and core data all live here \u2014 no need to check external docs.",
       "",
-      "Terminology & naming: For 'what is X?' or naming questions, fetch `productbrain://terminology`",
-      "or use the `name-check` prompt to validate names against the glossary.",
-      "",
       "Workflow:",
       "  1. Verify: call `health` to confirm connectivity.",
-      "  2. Terminology: fetch `productbrain://terminology` or use `name-check` prompt for naming questions.",
-      "  3. Discover: use `kb-search` to find entries by text, or `list-entries` to browse a collection.",
+      "  2. Terminology: fetch `productbrain://terminology` or use `name-check` prompt.",
+      "  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. Capture: use `smart-capture` to create entries \u2014 it auto-links related entries and",
-      "     returns a quality scorecard in one call. Use `create-entry` only when you need",
-      "     full control over every field.",
-      "  6. Connect: use `suggest-links` then `relate-entries` to build the graph.",
-      "  7. Quality: use `quality-check` to assess entry completeness.",
-      "  8. Debug: use `mcp-audit` to see what backend calls happened this session.",
+      "  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.",
       "",
-      "Always prefer `smart-capture` over `create-entry` or `quick-capture` for new entries.",
-      "Always prefer kb-search or list-entries before get-entry \u2014 discover, then drill in.",
+      "Always discover before drilling in (search or list-entries before get-entry).",
       "",
       "Orientation:",
-      "  When you need to understand the system \u2014 architecture, data model, rules,",
-      "  or analytics \u2014 fetch the `productbrain://orientation` resource first.",
-      "  It gives you the map. Then use the appropriate tool to drill in."
+      "  Fetch `productbrain://orientation` to understand architecture, data model, rules,",
+      "  and analytics. It is the map. Then use tools to drill in."
     ].join("\n")
   }
 );
+var enabledModules = new Set(
+  (process.env.PB_MODULES ?? "core,gitchain").split(",").map((m) => m.trim().toLowerCase())
+);
 registerKnowledgeTools(server);
 registerLabelTools(server);
 registerHealthTools(server);
 registerVerifyTools(server);
 registerSmartCaptureTools(server);
-registerArchitectureTools(server);
 registerWorkflowTools(server);
-registerGitChainTools(server);
+if (enabledModules.has("gitchain")) registerGitChainTools(server);
+if (enabledModules.has("arch")) registerArchitectureTools(server);
 registerResources(server);
 registerPrompts(server);
 var transport = new StdioServerTransport();