@productbrain/mcp 0.0.1-beta.2 → 0.0.1-beta.21

package/dist/chunk-CXYNWTRQ.js

@@ -0,0 +1,1425 @@
+import {
+  trackToolCall
+} from "./chunk-XBMI6QHR.js";
+
+// src/tools/smart-capture.ts
+import { z } from "zod";
+
+// src/auth.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestStore = new AsyncLocalStorage();
+function runWithAuth(auth, fn) {
+  return requestStore.run(auth, fn);
+}
+function getRequestApiKey() {
+  return requestStore.getStore()?.apiKey;
+}
+var SESSION_TTL_MS = 30 * 60 * 1e3;
+var MAX_KEYS = 100;
+var keyStateMap = /* @__PURE__ */ new Map();
+function newKeyState() {
+  return {
+    workspaceId: null,
+    workspaceSlug: null,
+    workspaceName: null,
+    workspaceCreatedAt: null,
+    agentSessionId: null,
+    apiKeyId: null,
+    apiKeyScope: "readwrite",
+    sessionOriented: false,
+    sessionClosed: false,
+    lastAccess: Date.now()
+  };
+}
+function getKeyState(apiKey) {
+  let s = keyStateMap.get(apiKey);
+  if (!s) {
+    s = newKeyState();
+    keyStateMap.set(apiKey, s);
+    evictStale();
+  }
+  s.lastAccess = Date.now();
+  return s;
+}
+function evictStale() {
+  if (keyStateMap.size <= MAX_KEYS) return;
+  const now = Date.now();
+  for (const [key, s] of keyStateMap) {
+    if (now - s.lastAccess > SESSION_TTL_MS) keyStateMap.delete(key);
+  }
+  if (keyStateMap.size > MAX_KEYS) {
+    const sorted = [...keyStateMap.entries()].sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+    for (let i = 0; i < sorted.length - MAX_KEYS; i++) {
+      keyStateMap.delete(sorted[i][0]);
+    }
+  }
+}
+
+// src/client.ts
+var DEFAULT_CLOUD_URL = "https://trustworthy-kangaroo-277.convex.site";
+var _stdioState = {
+  workspaceId: null,
+  workspaceSlug: null,
+  workspaceName: null,
+  workspaceCreatedAt: null,
+  agentSessionId: null,
+  apiKeyId: null,
+  apiKeyScope: "readwrite",
+  sessionOriented: false,
+  sessionClosed: false,
+  lastAccess: 0
+};
+function state() {
+  const reqKey = getRequestApiKey();
+  if (reqKey) return getKeyState(reqKey);
+  return _stdioState;
+}
+function getActiveApiKey() {
+  const fromRequest = getRequestApiKey();
+  if (fromRequest) return fromRequest;
+  const fromEnv = process.env.PRODUCTBRAIN_API_KEY;
+  if (!fromEnv) throw new Error("No API key available \u2014 set PRODUCTBRAIN_API_KEY or provide Bearer token");
+  return fromEnv;
+}
+function getAgentSessionId() {
+  return state().agentSessionId;
+}
+function isSessionOriented() {
+  return state().sessionOriented;
+}
+function setSessionOriented(value) {
+  state().sessionOriented = value;
+}
+async function startAgentSession() {
+  const workspaceId = await getWorkspaceId();
+  const s = state();
+  if (!s.apiKeyId) {
+    throw new Error("Cannot start session: API key ID not resolved. Ensure workspace resolution completed.");
+  }
+  const result = await mcpCall("agent.startSession", {
+    workspaceId,
+    apiKeyId: s.apiKeyId
+  });
+  s.agentSessionId = result.sessionId;
+  s.apiKeyScope = result.toolsScope;
+  s.sessionOriented = false;
+  s.sessionClosed = false;
+  return result;
+}
+async function closeAgentSession() {
+  const s = state();
+  if (!s.agentSessionId) return;
+  try {
+    await mcpCall("agent.closeSession", {
+      sessionId: s.agentSessionId,
+      status: "closed"
+    });
+  } finally {
+    s.sessionClosed = true;
+    s.agentSessionId = null;
+    s.sessionOriented = false;
+  }
+}
+async function orphanAgentSession() {
+  const s = state();
+  if (!s.agentSessionId) return;
+  try {
+    await mcpCall("agent.closeSession", {
+      sessionId: s.agentSessionId,
+      status: "orphaned"
+    });
+  } catch {
+  } finally {
+    s.agentSessionId = null;
+    s.sessionOriented = false;
+  }
+}
+function touchSessionActivity() {
+  const s = state();
+  if (!s.agentSessionId) return;
+  mcpCall("agent.touchSession", {
+    sessionId: s.agentSessionId
+  }).catch(() => {
+  });
+}
+async function recordSessionActivity(activity) {
+  const s = state();
+  if (!s.agentSessionId) return;
+  try {
+    await mcpCall("agent.recordActivity", {
+      sessionId: s.agentSessionId,
+      ...activity
+    });
+  } catch {
+  }
+}
+var AUDIT_BUFFER_SIZE = 50;
+var auditBuffer = [];
+function bootstrap() {
+  const pbKey = process.env.PRODUCTBRAIN_API_KEY;
+  if (!pbKey?.startsWith("pb_sk_")) {
+    throw new Error(
+      "PRODUCTBRAIN_API_KEY is required and must start with 'pb_sk_'. Generate one at Settings > API Keys in the Product OS UI."
+    );
+  }
+  process.env.CONVEX_SITE_URL ??= process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
+}
+function bootstrapHttp() {
+  process.env.CONVEX_SITE_URL ??= process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
+}
+function getEnv(key) {
+  const value = process.env[key];
+  if (!value) throw new Error(`${key} environment variable is required`);
+  return value;
+}
+function shouldLogAudit(status) {
+  return status === "error" || process.env.MCP_DEBUG === "1";
+}
+function audit(fn, status, durationMs, errorMsg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const workspace = state().workspaceId ?? "unresolved";
+  const entry = { ts, fn, workspace, status, durationMs };
+  if (errorMsg) entry.error = errorMsg;
+  auditBuffer.push(entry);
+  if (auditBuffer.length > AUDIT_BUFFER_SIZE) auditBuffer.shift();
+  trackToolCall(fn, status, durationMs, workspace, errorMsg);
+  if (!shouldLogAudit(status)) return;
+  const base = `[MCP-AUDIT] ${ts} fn=${fn} workspace=${workspace} status=${status} duration=${durationMs}ms`;
+  if (status === "error" && errorMsg) {
+    process.stderr.write(`${base} error=${JSON.stringify(errorMsg)}
+`);
+  } else {
+    process.stderr.write(`${base}
+`);
+  }
+}
+function getAuditLog() {
+  return auditBuffer;
+}
+async function mcpCall(fn, args = {}) {
+  const siteUrl = getEnv("CONVEX_SITE_URL").replace(/\/$/, "");
+  const apiKey = getActiveApiKey();
+  const start = Date.now();
+  let res;
+  try {
+    res = await fetch(`${siteUrl}/api/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ fn, args })
+    });
+  } catch (err) {
+    audit(fn, "error", Date.now() - start, err.message);
+    throw new Error(`MCP call "${fn}" network error: ${err.message}`);
+  }
+  const json = await res.json();
+  if (!res.ok || json.error) {
+    audit(fn, "error", Date.now() - start, json.error);
+    throw new Error(`MCP call "${fn}" failed (${res.status}): ${json.error ?? "unknown error"}`);
+  }
+  audit(fn, "ok", Date.now() - start);
+  const s = state();
+  if (s.agentSessionId && fn !== "agent.touchSession" && fn !== "agent.startSession") {
+    touchSessionActivity();
+  }
+  return json.data;
+}
+var resolveInFlightMap = /* @__PURE__ */ new Map();
+async function getWorkspaceId() {
+  const s = state();
+  if (s.workspaceId) return s.workspaceId;
+  const apiKey = getActiveApiKey();
+  const existing = resolveInFlightMap.get(apiKey);
+  if (existing) return existing;
+  const promise = resolveWorkspaceWithRetry().finally(() => resolveInFlightMap.delete(apiKey));
+  resolveInFlightMap.set(apiKey, promise);
+  return promise;
+}
+async function resolveWorkspaceWithRetry(maxRetries = 2) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const workspace = await mcpCall("resolveWorkspace", {});
+      if (!workspace) {
+        throw new Error(
+          "API key is valid but no workspace is associated. Run `npx productbrain setup` or regenerate your key."
+        );
+      }
+      const s = state();
+      s.workspaceId = workspace._id;
+      s.workspaceSlug = workspace.slug;
+      s.workspaceName = workspace.name;
+      s.workspaceCreatedAt = workspace.createdAt ?? null;
+      if (workspace.keyScope) s.apiKeyScope = workspace.keyScope;
+      if (workspace.keyId) s.apiKeyId = workspace.keyId;
+      return s.workspaceId;
+    } catch (err) {
+      lastError = err;
+      const isTransient = /network error|fetch failed|ECONNREFUSED|ETIMEDOUT/i.test(err.message);
+      if (!isTransient || attempt === maxRetries) break;
+      const delay = 1e3 * (attempt + 1);
+      process.stderr.write(
+        `[MCP] Workspace resolution failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms...
+`
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+async function getWorkspaceContext() {
+  const workspaceId = await getWorkspaceId();
+  const s = state();
+  return {
+    workspaceId,
+    workspaceSlug: s.workspaceSlug ?? "unknown",
+    workspaceName: s.workspaceName ?? "unknown",
+    createdAt: s.workspaceCreatedAt
+  };
+}
+async function mcpQuery(fn, args = {}) {
+  const workspaceId = await getWorkspaceId();
+  return mcpCall(fn, { ...args, workspaceId });
+}
+async function mcpMutation(fn, args = {}) {
+  const workspaceId = await getWorkspaceId();
+  return mcpCall(fn, { ...args, workspaceId });
+}
+function requireWriteAccess() {
+  const s = state();
+  if (!s.agentSessionId) {
+    throw new Error(
+      "Agent session required for write operations. Call `agent-start` first."
+    );
+  }
+  if (s.sessionClosed) {
+    throw new Error(
+      "Agent session has been closed. Write tools are no longer available."
+    );
+  }
+  if (!s.sessionOriented) {
+    throw new Error(
+      "Orientation required before writing to the Chain. Call 'orient' first."
+    );
+  }
+  if (s.apiKeyScope === "read") {
+    throw new Error(
+      "This API key has read-only scope. Write tools are not available."
+    );
+  }
+}
+async function recoverSessionState() {
+  const s = state();
+  if (!s.workspaceId) return;
+  try {
+    const session = await mcpCall("agent.getActiveSession", { workspaceId: s.workspaceId });
+    if (session && session.status === "active") {
+      s.agentSessionId = session._id;
+      s.sessionOriented = session.oriented;
+      s.apiKeyScope = session.toolsScope;
+      s.sessionClosed = false;
+    }
+  } catch {
+  }
+}
+
+// src/tools/smart-capture.ts
+var AREA_KEYWORDS = {
+  "Architecture": ["convex", "schema", "database", "migration", "api", "backend", "infrastructure", "scaling", "performance"],
+  "Chain": ["knowledge", "glossary", "entry", "collection", "terminology", "drift", "graph", "chain", "commit"],
+  "AI & MCP Integration": ["mcp", "ai", "cursor", "agent", "tool", "llm", "prompt", "context"],
+  "Developer Experience": ["dx", "developer", "ide", "workflow", "friction", "ceremony"],
+  "Governance & Decision-Making": ["governance", "decision", "rule", "policy", "compliance", "approval"],
+  "Analytics & Tracking": ["analytics", "posthog", "tracking", "event", "metric", "funnel"],
+  "Security": ["security", "auth", "api key", "permission", "access", "token"]
+};
+function inferArea(text) {
+  const lower = text.toLowerCase();
+  let bestArea = "";
+  let bestScore = 0;
+  for (const [area, keywords] of Object.entries(AREA_KEYWORDS)) {
+    const score = keywords.filter((kw) => lower.includes(kw)).length;
+    if (score > bestScore) {
+      bestScore = score;
+      bestArea = area;
+    }
+  }
+  return bestArea;
+}
+function inferDomain(text) {
+  return inferArea(text) || "";
+}
+var COMMON_CHECKS = {
+  clearName: {
+    id: "clear-name",
+    label: "Clear, specific name (not vague)",
+    check: (ctx) => ctx.name.length > 10 && !["new tension", "new entry", "untitled", "test"].includes(ctx.name.toLowerCase()),
+    suggestion: () => "Rename to something specific \u2014 describe the actual problem or concept."
+  },
+  hasDescription: {
+    id: "has-description",
+    label: "Description provided (>50 chars)",
+    check: (ctx) => ctx.description.length > 50,
+    suggestion: () => "Add a fuller description explaining context and impact."
+  },
+  hasRelations: {
+    id: "has-relations",
+    label: "At least 1 relation created",
+    check: (ctx) => ctx.linksCreated.length >= 1,
+    suggestion: () => "Use `suggest-links` and `relate-entries` to add more connections."
+  },
+  diverseRelations: {
+    id: "diverse-relations",
+    label: "Relations span multiple collections",
+    check: (ctx) => {
+      const colls = new Set(ctx.linksCreated.map((l) => l.targetCollection));
+      return colls.size >= 2;
+    },
+    suggestion: () => "Try linking to entries in different collections (glossary, business-rules, strategy)."
+  },
+  hasType: {
+    id: "has-type",
+    label: "Has canonical type",
+    check: (ctx) => !!ctx.data?.canonicalKey || !!ctx.canonicalKey,
+    suggestion: () => "Classify this entry with a canonical type for better context assembly. Use update-entry to set canonicalKey."
+  }
+};
+var PROFILES = /* @__PURE__ */ new Map([
+  ["tensions", {
+    idPrefix: "TEN",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [
+      { key: "priority", value: "medium" },
+      { key: "date", value: "today" },
+      { key: "raised", value: "infer" },
+      { key: "severity", value: "infer" }
+    ],
+    recommendedRelationTypes: ["surfaces_tension_in", "references", "belongs_to", "related_to"],
+    inferField: (ctx) => {
+      const fields = {};
+      const text = `${ctx.name} ${ctx.description}`;
+      const area = inferArea(text);
+      if (area) fields.raised = area;
+      if (text.toLowerCase().includes("critical") || text.toLowerCase().includes("blocker")) {
+        fields.severity = "critical";
+      } else if (text.toLowerCase().includes("bottleneck") || text.toLowerCase().includes("scaling") || text.toLowerCase().includes("breaking")) {
+        fields.severity = "high";
+      } else {
+        fields.severity = "medium";
+      }
+      if (area) fields.affectedArea = area;
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-severity",
+        label: "Severity specified",
+        check: (ctx) => !!ctx.data.severity && ctx.data.severity !== "",
+        suggestion: (ctx) => {
+          const text = `${ctx.name} ${ctx.description}`.toLowerCase();
+          const inferred = text.includes("critical") ? "critical" : text.includes("bottleneck") ? "high" : "medium";
+          return `Set severity \u2014 suggest: ${inferred} (based on description keywords).`;
+        }
+      },
+      {
+        id: "has-affected-area",
+        label: "Affected area identified",
+        check: (ctx) => !!ctx.data.affectedArea && ctx.data.affectedArea !== "",
+        suggestion: (ctx) => {
+          const area = inferArea(`${ctx.name} ${ctx.description}`);
+          return area ? `Set affectedArea \u2014 suggest: "${area}" (inferred from content).` : "Specify which product area or domain this tension impacts.";
+        }
+      }
+    ]
+  }],
+  ["business-rules", {
+    idPrefix: "SOS",
+    governedDraft: true,
+    descriptionField: "description",
+    defaults: [
+      { key: "severity", value: "medium" },
+      { key: "domain", value: "infer" }
+    ],
+    recommendedRelationTypes: ["governs", "references", "conflicts_with", "related_to"],
+    inferField: (ctx) => {
+      const fields = {};
+      const domain = inferDomain(`${ctx.name} ${ctx.description}`);
+      if (domain) fields.domain = domain;
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-rationale",
+        label: "Rationale provided",
+        check: (ctx) => typeof ctx.data.rationale === "string" && ctx.data.rationale.length > 10,
+        suggestion: () => "Add a rationale explaining why this rule exists via `update-entry`."
+      },
+      {
+        id: "has-domain",
+        label: "Domain specified",
+        check: (ctx) => !!ctx.data.domain && ctx.data.domain !== "",
+        suggestion: (ctx) => {
+          const domain = inferDomain(`${ctx.name} ${ctx.description}`);
+          return domain ? `Set domain \u2014 suggest: "${domain}" (inferred from content).` : "Specify the business domain this rule belongs to.";
+        }
+      }
+    ]
+  }],
+  ["glossary", {
+    idPrefix: "GT",
+    governedDraft: true,
+    descriptionField: "canonical",
+    defaults: [
+      { key: "category", value: "infer" }
+    ],
+    recommendedRelationTypes: ["defines_term_for", "confused_with", "related_to", "references"],
+    inferField: (ctx) => {
+      const fields = {};
+      const area = inferArea(`${ctx.name} ${ctx.description}`);
+      if (area) {
+        const categoryMap = {
+          "Architecture": "Platform & Architecture",
+          "Chain": "Knowledge Management",
+          "AI & MCP Integration": "AI & Developer Tools",
+          "Developer Experience": "AI & Developer Tools",
+          "Governance & Decision-Making": "Governance & Process",
+          "Analytics & Tracking": "Platform & Architecture",
+          "Security": "Platform & Architecture"
+        };
+        fields.category = categoryMap[area] ?? "";
+      }
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-canonical",
+        label: "Canonical definition provided (>20 chars)",
+        check: (ctx) => {
+          const canonical = ctx.data.canonical;
+          return typeof canonical === "string" && canonical.length > 20;
+        },
+        suggestion: () => "Add a clear canonical definition \u2014 this is the single source of truth for this term."
+      },
+      COMMON_CHECKS.hasRelations,
+      {
+        id: "has-category",
+        label: "Category assigned",
+        check: (ctx) => !!ctx.data.category && ctx.data.category !== "",
+        suggestion: () => "Assign a category (e.g., 'Platform & Architecture', 'Governance & Process')."
+      }
+    ]
+  }],
+  ["decisions", {
+    idPrefix: "DEC",
+    governedDraft: false,
+    descriptionField: "rationale",
+    defaults: [
+      { key: "date", value: "today" },
+      { key: "decidedBy", value: "infer" }
+    ],
+    recommendedRelationTypes: ["informs", "references", "replaces", "related_to"],
+    inferField: (ctx) => {
+      const fields = {};
+      const area = inferArea(`${ctx.name} ${ctx.description}`);
+      if (area) fields.decidedBy = area;
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-rationale",
+        label: "Rationale provided (>30 chars)",
+        check: (ctx) => {
+          const rationale = ctx.data.rationale;
+          return typeof rationale === "string" && rationale.length > 30;
+        },
+        suggestion: () => "Explain why this decision was made \u2014 what was considered and rejected?"
+      },
+      COMMON_CHECKS.hasRelations,
+      {
+        id: "has-date",
+        label: "Decision date recorded",
+        check: (ctx) => !!ctx.data.date && ctx.data.date !== "",
+        suggestion: () => "Record when this decision was made."
+      }
+    ]
+  }],
+  ["features", {
+    idPrefix: "FEAT",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["belongs_to", "depends_on", "surfaces_tension_in", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-owner",
+        label: "Owner assigned",
+        check: (ctx) => !!ctx.data.owner && ctx.data.owner !== "",
+        suggestion: () => "Assign an owner team or product area."
+      },
+      {
+        id: "has-rationale",
+        label: "Rationale documented",
+        check: (ctx) => !!ctx.data.rationale && String(ctx.data.rationale).length > 20,
+        suggestion: () => "Explain why this feature matters \u2014 what problem does it solve?"
+      }
+    ]
+  }],
+  ["audiences", {
+    idPrefix: "AUD",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["fills_slot", "informs", "related_to", "references"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-behaviors",
+        label: "Behaviors described",
+        check: (ctx) => typeof ctx.data.behaviors === "string" && ctx.data.behaviors.length > 20,
+        suggestion: () => "Describe how this audience segment behaves \u2014 what do they do, what tools do they use?"
+      }
+    ]
+  }],
+  ["strategy", {
+    idPrefix: "STR",
+    governedDraft: true,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["informs", "governs", "belongs_to", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      COMMON_CHECKS.diverseRelations
+    ]
+  }],
+  ["maps", {
+    idPrefix: "MAP",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["fills_slot", "references", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription
+    ]
+  }],
+  ["chains", {
+    idPrefix: "CHN",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["informs", "references", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription
+    ]
+  }],
+  ["standards", {
+    idPrefix: "STD",
+    governedDraft: true,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["governs", "defines_term_for", "references", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType
+    ]
+  }],
+  ["tracking-events", {
+    idPrefix: "TE",
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["references", "belongs_to", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription
+    ]
+  }]
+]);
+var FALLBACK_PROFILE = {
+  idPrefix: "ENT",
+  governedDraft: false,
+  descriptionField: "description",
+  defaults: [],
+  recommendedRelationTypes: ["related_to", "references"],
+  qualityChecks: [
+    COMMON_CHECKS.clearName,
+    COMMON_CHECKS.hasDescription,
+    COMMON_CHECKS.hasRelations,
+    COMMON_CHECKS.hasType
+  ]
+};
+function generateEntryId(prefix) {
+  const effectivePrefix = prefix || "ENT";
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let suffix = "";
+  for (let i = 0; i < 6; i++) {
+    suffix += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `${effectivePrefix}-${suffix}`;
+}
+function extractSearchTerms(name, description) {
+  const text = `${name} ${description}`;
+  return text.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3).slice(0, 8).join(" ");
+}
+function computeLinkConfidence(candidate, sourceName, sourceDescription, sourceCollection, candidateCollection) {
+  const text = `${sourceName} ${sourceDescription}`.toLowerCase();
+  const candidateName = candidate.name.toLowerCase();
+  let score = 0;
+  if (text.includes(candidateName) && candidateName.length > 3) {
+    score += 40;
+  }
+  const candidateWords = candidateName.split(/\s+/).filter((w) => w.length > 3);
+  const matchingWords = candidateWords.filter((w) => text.includes(w));
+  score += matchingWords.length / Math.max(candidateWords.length, 1) * 30;
+  const HUB_COLLECTIONS = /* @__PURE__ */ new Set(["strategy", "features"]);
+  if (HUB_COLLECTIONS.has(candidateCollection)) {
+    score += 15;
+  }
+  if (candidateCollection !== sourceCollection) {
+    score += 10;
+  }
+  return Math.min(score, 100);
+}
+function inferRelationType(sourceCollection, targetCollection, profile) {
+  const typeMap = {
+    tensions: {
+      glossary: "surfaces_tension_in",
+      "business-rules": "references",
+      strategy: "belongs_to",
+      features: "surfaces_tension_in",
+      decisions: "references"
+    },
+    "business-rules": {
+      glossary: "references",
+      features: "governs",
+      strategy: "belongs_to",
+      tensions: "references"
+    },
+    glossary: {
+      features: "defines_term_for",
+      "business-rules": "references",
+      strategy: "references"
+    },
+    decisions: {
+      features: "informs",
+      "business-rules": "references",
+      strategy: "references",
+      tensions: "references"
+    }
+  };
+  return typeMap[sourceCollection]?.[targetCollection] ?? profile.recommendedRelationTypes[0] ?? "related_to";
+}
+function scoreQuality(ctx, profile) {
+  const checks = profile.qualityChecks.map((qc) => {
+    const passed2 = qc.check(ctx);
+    return {
+      id: qc.id,
+      label: qc.label,
+      passed: passed2,
+      suggestion: passed2 ? void 0 : qc.suggestion?.(ctx)
+    };
+  });
+  const passed = checks.filter((c) => c.passed).length;
+  const total = checks.length;
+  const score = total > 0 ? Math.round(passed / total * 10) : 10;
+  return { score, maxScore: 10, checks };
+}
+function formatQualityReport(result) {
+  const lines = [`## Quality: ${result.score}/${result.maxScore}`];
+  for (const check of result.checks) {
+    const icon = check.passed ? "[x]" : "[ ]";
+    const suggestion = check.passed ? "" : ` -- ${check.suggestion ?? ""}`;
+    lines.push(`${icon} ${check.label}${suggestion}`);
+  }
+  return lines.join("\n");
+}
+async function checkEntryQuality(entryId) {
+  const entry = await mcpQuery("chain.getEntry", { entryId });
+  if (!entry) {
+    return {
+      text: `Entry \`${entryId}\` not found. Try search to find the right ID.`,
+      quality: { score: 0, maxScore: 10, checks: [] }
+    };
+  }
+  const collections = await mcpQuery("chain.listCollections");
+  const collMap = /* @__PURE__ */ new Map();
+  for (const c of collections) collMap.set(c._id, c.slug);
+  const collectionSlug = collMap.get(entry.collectionId) ?? "unknown";
+  const profile = PROFILES.get(collectionSlug) ?? FALLBACK_PROFILE;
+  const relations = await mcpQuery("chain.listEntryRelations", { entryId });
+  const linksCreated = [];
+  for (const r of relations) {
+    const otherId = r.fromId === entry._id ? r.toId : r.fromId;
+    linksCreated.push({
+      targetEntryId: otherId,
+      targetName: "",
+      targetCollection: "",
+      relationType: r.type
+    });
+  }
+  const descField = profile.descriptionField;
+  const description = typeof entry.data?.[descField] === "string" ? entry.data[descField] : "";
+  const ctx = {
+    collection: collectionSlug,
+    name: entry.name,
+    description,
+    data: entry.data ?? {},
+    entryId: entry.entryId ?? "",
+    canonicalKey: entry.canonicalKey,
+    linksCreated,
+    linksSuggested: [],
+    collectionFields: []
+  };
+  const quality = scoreQuality(ctx, profile);
+  const lines = [
+    `# Quality Check: ${entry.entryId ?? entry.name}`,
+    `**${entry.name}** in \`${collectionSlug}\` [${entry.status}]`,
+    "",
+    formatQualityReport(quality)
+  ];
+  if (quality.score < 10) {
+    const failedChecks = quality.checks.filter((c) => !c.passed && c.suggestion);
+    if (failedChecks.length > 0) {
+      lines.push("");
+      lines.push(`_To improve: use \`update-entry\` to fill missing fields, or \`relate-entries\` to add connections._`);
+    }
+  }
+  return { text: lines.join("\n"), quality };
+}
+var GOVERNED_COLLECTIONS = /* @__PURE__ */ new Set([
+  "glossary",
+  "business-rules",
+  "principles",
+  "standards",
+  "strategy",
+  "features"
+]);
+var AUTO_LINK_CONFIDENCE_THRESHOLD = 35;
+var MAX_AUTO_LINKS = 5;
+var MAX_SUGGESTIONS = 5;
+function registerSmartCaptureTools(server) {
+  server.registerTool(
+    "capture",
+    {
+      title: "Capture",
+      description: "The single tool for creating knowledge entries. Creates an entry, auto-links related entries, and returns a quality scorecard \u2014 all in one call. Provide a collection, name, and description \u2014 everything else is inferred or auto-filled.\n\nSupported collections with smart profiles: tensions, business-rules, glossary, decisions, features, audiences, strategy, standards, maps, chains, tracking-events.\nAll other collections get an ENT-{random} ID and sensible defaults.\n\nAlways creates as 'draft' for governed collections. Use `update-entry` for post-creation adjustments.",
+      inputSchema: {
+        collection: z.string().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'"),
+        name: z.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
+        description: z.string().describe("Full context \u2014 what's happening, why it matters, what you observed"),
+        context: z.string().optional().describe("Optional additional context (e.g. 'Observed during gather-context calls taking 700ms+')"),
+        entryId: z.string().optional().describe("Optional custom entry ID (e.g. 'TEN-my-id'). Auto-generated if omitted."),
+        canonicalKey: z.string().optional().describe("Semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted.")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ collection, name, description, context, entryId, canonicalKey }) => {
+      requireWriteAccess();
+      const profile = PROFILES.get(collection) ?? FALLBACK_PROFILE;
+      const col = await mcpQuery("chain.getCollection", { slug: collection });
+      if (!col) {
+        const displayName = collection.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+        return {
+          content: [{
+            type: "text",
+            text: `Collection \`${collection}\` not found.
+
+**To create it**, run:
+\`\`\`
+create-collection slug="${collection}" name="${displayName}" description="..."
+\`\`\`
+
+Or use \`list-collections\` to see available collections.`
+          }]
+        };
+      }
+      const data = {};
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      for (const field of col.fields ?? []) {
+        const key = field.key;
+        if (key === profile.descriptionField) {
+          data[key] = description;
+        } else if (field.type === "array" || field.type === "multi-select") {
+          data[key] = [];
+        } else if (field.type === "select") {
+        } else {
+          data[key] = "";
+        }
+      }
+      for (const def of profile.defaults) {
+        if (def.value === "today") {
+          data[def.key] = today;
+        } else if (def.value !== "infer") {
+          data[def.key] = def.value;
+        }
+      }
+      if (profile.inferField) {
+        const inferred = profile.inferField({
+          collection,
+          name,
+          description,
+          context,
+          data,
+          entryId: "",
+          linksCreated: [],
+          linksSuggested: [],
+          collectionFields: col.fields ?? []
+        });
+        for (const [key, val] of Object.entries(inferred)) {
+          if (val !== void 0 && val !== "") {
+            data[key] = val;
+          }
+        }
+      }
+      if (!data[profile.descriptionField] && !data.description && !data.canonical) {
+        data[profile.descriptionField || "description"] = description;
+      }
+      const status = GOVERNED_COLLECTIONS.has(collection) ? "draft" : "draft";
+      const finalEntryId = entryId ?? generateEntryId(profile.idPrefix);
+      let internalId;
+      try {
+        const agentId = getAgentSessionId();
+        internalId = await mcpMutation("chain.createEntry", {
+          collectionSlug: collection,
+          entryId: finalEntryId || void 0,
+          name,
+          status,
+          data,
+          canonicalKey,
+          createdBy: agentId ? `agent:${agentId}` : "capture",
+          sessionId: agentId ?? void 0
+        });
+        await recordSessionActivity({ entryCreated: internalId });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("Duplicate") || msg.includes("already exists")) {
+          return {
+            content: [{
+              type: "text",
+              text: `# Cannot Capture \u2014 Duplicate Detected
+
+${msg}
+
+Use \`get-entry\` to inspect the existing entry, or \`update-entry\` to modify it.`
+            }]
+          };
+        }
+        throw error;
+      }
+      const linksCreated = [];
+      const linksSuggested = [];
+      const searchQuery = extractSearchTerms(name, description);
+      if (searchQuery) {
+        const [searchResults, allCollections] = await Promise.all([
+          mcpQuery("chain.searchEntries", { query: searchQuery }),
+          mcpQuery("chain.listCollections")
+        ]);
+        const collMap = /* @__PURE__ */ new Map();
+        for (const c of allCollections) collMap.set(c._id, c.slug);
+        const candidates = (searchResults ?? []).filter((r) => r.entryId !== finalEntryId && r._id !== internalId).map((r) => ({
+          ...r,
+          collSlug: collMap.get(r.collectionId) ?? "unknown",
+          confidence: computeLinkConfidence(r, name, description, collection, collMap.get(r.collectionId) ?? "unknown")
+        })).sort((a, b) => b.confidence - a.confidence);
+        for (const c of candidates) {
+          if (linksCreated.length >= MAX_AUTO_LINKS) break;
+          if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
+          if (!c.entryId || !finalEntryId) continue;
+          const relationType = inferRelationType(collection, c.collSlug, profile);
+          try {
+            await mcpMutation("chain.createEntryRelation", {
+              fromEntryId: finalEntryId,
+              toEntryId: c.entryId,
+              type: relationType
+            });
+            linksCreated.push({
+              targetEntryId: c.entryId,
+              targetName: c.name,
+              targetCollection: c.collSlug,
+              relationType
+            });
+          } catch {
+          }
+        }
+        const linkedIds = new Set(linksCreated.map((l) => l.targetEntryId));
+        for (const c of candidates) {
+          if (linksSuggested.length >= MAX_SUGGESTIONS) break;
+          if (linkedIds.has(c.entryId)) continue;
+          if (c.confidence < 10) continue;
+          const preview = extractPreview(c.data, 80);
+          const reason = c.confidence >= AUTO_LINK_CONFIDENCE_THRESHOLD ? "high relevance (already linked)" : `"${c.name.toLowerCase().split(/\s+/).filter((w) => `${name} ${description}`.toLowerCase().includes(w) && w.length > 3).slice(0, 2).join('", "')}" appears in content`;
+          linksSuggested.push({
+            entryId: c.entryId,
+            name: c.name,
+            collection: c.collSlug,
+            reason,
+            preview
+          });
+        }
+      }
+      const captureCtx = {
+        collection,
+        name,
+        description,
+        context,
+        data,
+        entryId: finalEntryId,
+        canonicalKey,
+        linksCreated,
+        linksSuggested,
+        collectionFields: col.fields ?? []
+      };
+      const quality = scoreQuality(captureCtx, profile);
+      let cardinalityWarning = null;
+      const resolvedCK = canonicalKey ?? captureCtx.canonicalKey;
+      if (resolvedCK) {
+        try {
+          const check = await mcpQuery("chain.checkCardinalityWarning", {
+            canonicalKey: resolvedCK
+          });
+          if (check?.warning) {
+            cardinalityWarning = check.warning;
+          }
+        } catch {
+        }
+      }
+      const contradictionWarnings = await runContradictionCheck(name, description);
+      if (contradictionWarnings.length > 0) {
+        await recordSessionActivity({ contradictionWarning: true });
+      }
+      const wsCtx = await getWorkspaceContext();
+      const lines = [
+        `# Captured: ${finalEntryId || name}`,
+        `**${name}** added to \`${collection}\` as \`${status}\``,
+        `**Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})`
+      ];
+      if (linksCreated.length > 0) {
+        lines.push("");
+        lines.push(`## Auto-linked (${linksCreated.length})`);
+        for (const link of linksCreated) {
+          lines.push(`- -> **${link.relationType}** ${link.targetEntryId}: ${link.targetName} [${link.targetCollection}]`);
+        }
+      }
+      if (linksSuggested.length > 0) {
+        lines.push("");
+        lines.push("## Suggested links (review and use relate-entries)");
+        for (let i = 0; i < linksSuggested.length; i++) {
+          const s = linksSuggested[i];
+          const preview = s.preview ? ` \u2014 ${s.preview}` : "";
+          lines.push(`${i + 1}. **${s.entryId ?? "(no ID)"}**: ${s.name} [${s.collection}]${preview}`);
+        }
+      }
+      lines.push("");
+      lines.push(formatQualityReport(quality));
+      const failedChecks = quality.checks.filter((c) => !c.passed);
+      if (failedChecks.length > 0) {
+        lines.push("");
+        lines.push(`_To improve: \`update-entry entryId="${finalEntryId}"\` to fill missing fields._`);
+      }
+      if (cardinalityWarning) {
+        lines.push("");
+        lines.push(`**Cardinality warning:** ${cardinalityWarning}`);
+      }
+      if (contradictionWarnings.length > 0) {
+        lines.push("");
+        lines.push("\u26A0 Contradiction check: proposed entry matched existing governance entries:");
+        for (const w of contradictionWarnings) {
+          lines.push(`- ${w.name} (${w.collection}, ${w.entryId}) \u2014 has 'governs' relation to ${w.governsCount} entries`);
+        }
+        lines.push("Run gather-context on these entries before committing.");
+      }
+      lines.push("");
+      lines.push("## Next Steps");
+      const eid = finalEntryId || "(check entry ID)";
+      lines.push(`1. **Connect it:** \`suggest-links entryId="${eid}"\` \u2014 discover what this should link to`);
+      lines.push(`2. **Commit it:** \`commit-entry entryId="${eid}"\` \u2014 promote from draft to SSOT on the Chain`);
+      if (failedChecks.length > 0) {
+        lines.push(`3. **Improve quality:** \`update-entry entryId="${eid}"\` \u2014 fill missing fields`);
+      }
+      try {
+        const readiness = await mcpQuery("chain.workspaceReadiness");
+        if (readiness && readiness.gaps && readiness.gaps.length > 0) {
+          const topGaps = readiness.gaps.slice(0, 2);
+          lines.push("");
+          lines.push(`## Workspace Readiness: ${readiness.score}%`);
+          for (const gap of topGaps) {
+            lines.push(`- _${gap.label}:_ ${gap.guidance}`);
+          }
+        }
+      } catch {
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "batch-capture",
+    {
+      title: "Batch Capture",
+      description: "Create multiple knowledge entries in one call. Ideal for workspace setup, document ingestion, or any scenario where you need to capture many entries at once.\n\nEach entry is created independently \u2014 if one fails, the others still succeed. Returns a compact summary instead of per-entry quality scorecards.\n\nAuto-linking runs per entry but contradiction checks and readiness hints are skipped for speed. Use `quality-check` on individual entries afterward if needed.",
+      inputSchema: {
+        entries: z.array(z.object({
+          collection: z.string().describe("Collection slug"),
+          name: z.string().describe("Display name"),
+          description: z.string().describe("Full context / definition"),
+          entryId: z.string().optional().describe("Optional custom entry ID")
+        })).min(1).max(50).describe("Array of entries to capture")
+      },
+      annotations: { destructiveHint: false }
+    },
+    async ({ entries }) => {
+      requireWriteAccess();
+      const agentId = getAgentSessionId();
+      const createdBy = agentId ? `agent:${agentId}` : "capture";
+      const results = [];
+      const allCollections = await mcpQuery("chain.listCollections");
+      const collCache = /* @__PURE__ */ new Map();
+      for (const c of allCollections) collCache.set(c.slug, c);
+      const collIdToSlug = /* @__PURE__ */ new Map();
+      for (const c of allCollections) collIdToSlug.set(c._id, c.slug);
+      for (const entry of entries) {
+        const profile = PROFILES.get(entry.collection) ?? FALLBACK_PROFILE;
+        const col = collCache.get(entry.collection);
+        if (!col) {
+          results.push({ name: entry.name, collection: entry.collection, entryId: "", ok: false, autoLinks: 0, error: `Collection "${entry.collection}" not found` });
+          continue;
+        }
+        const finalEntryId = entry.entryId ?? generateEntryId(profile.idPrefix);
+        const data = {};
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        for (const field of col.fields ?? []) {
+          const key = field.key;
+          if (key === profile.descriptionField) {
+            data[key] = entry.description;
+          } else if (field.type === "array" || field.type === "multi-select") {
+            data[key] = [];
+          } else if (field.type === "select") {
+          } else {
+            data[key] = "";
+          }
+        }
+        for (const def of profile.defaults) {
+          if (def.value === "today") data[def.key] = today;
+          else if (def.value !== "infer") data[def.key] = def.value;
+        }
+        if (profile.inferField) {
+          const inferred = profile.inferField({
+            collection: entry.collection,
+            name: entry.name,
+            description: entry.description,
+            data,
+            entryId: "",
+            linksCreated: [],
+            linksSuggested: [],
+            collectionFields: col.fields ?? []
+          });
+          for (const [key, val] of Object.entries(inferred)) {
+            if (val !== void 0 && val !== "") data[key] = val;
+          }
+        }
+        if (!data[profile.descriptionField] && !data.description && !data.canonical) {
+          data[profile.descriptionField || "description"] = entry.description;
+        }
+        try {
+          const internalId = await mcpMutation("chain.createEntry", {
+            collectionSlug: entry.collection,
+            entryId: finalEntryId,
+            name: entry.name,
+            status: "draft",
+            data,
+            createdBy,
+            sessionId: agentId ?? void 0
+          });
+          let autoLinkCount = 0;
+          const searchQuery = extractSearchTerms(entry.name, entry.description);
+          if (searchQuery) {
+            try {
+              const searchResults = await mcpQuery("chain.searchEntries", { query: searchQuery });
+              const candidates = (searchResults ?? []).filter((r) => r.entryId !== finalEntryId).map((r) => ({
+                ...r,
+                collSlug: collIdToSlug.get(r.collectionId) ?? "unknown",
+                confidence: computeLinkConfidence(r, entry.name, entry.description, entry.collection, collIdToSlug.get(r.collectionId) ?? "unknown")
+              })).sort((a, b) => b.confidence - a.confidence);
+              for (const c of candidates) {
+                if (autoLinkCount >= MAX_AUTO_LINKS) break;
+                if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
+                if (!c.entryId) continue;
+                const relationType = inferRelationType(entry.collection, c.collSlug, profile);
+                try {
+                  await mcpMutation("chain.createEntryRelation", {
+                    fromEntryId: finalEntryId,
+                    toEntryId: c.entryId,
+                    type: relationType
+                  });
+                  autoLinkCount++;
+                } catch {
+                }
+              }
+            } catch {
+            }
+          }
+          results.push({ name: entry.name, collection: entry.collection, entryId: finalEntryId, ok: true, autoLinks: autoLinkCount });
+          await recordSessionActivity({ entryCreated: internalId });
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          results.push({ name: entry.name, collection: entry.collection, entryId: finalEntryId, ok: false, autoLinks: 0, error: msg });
+        }
+      }
+      const created = results.filter((r) => r.ok);
+      const failed = results.filter((r) => !r.ok);
+      const totalAutoLinks = created.reduce((sum, r) => sum + r.autoLinks, 0);
+      const byCollection = /* @__PURE__ */ new Map();
+      for (const r of created) {
+        byCollection.set(r.collection, (byCollection.get(r.collection) ?? 0) + 1);
+      }
+      const lines = [
+        `# Batch Capture Complete`,
+        `**${created.length}** created, **${failed.length}** failed out of ${entries.length} total.`,
+        `**Auto-links created:** ${totalAutoLinks}`,
+        ""
+      ];
+      if (byCollection.size > 0) {
+        lines.push("## By Collection");
+        for (const [col, count] of byCollection) {
+          lines.push(`- \`${col}\`: ${count} entries`);
+        }
+        lines.push("");
+      }
+      if (created.length > 0) {
+        lines.push("## Created");
+        for (const r of created) {
+          const linkNote = r.autoLinks > 0 ? ` (${r.autoLinks} auto-links)` : "";
+          lines.push(`- **${r.entryId}**: ${r.name} [${r.collection}]${linkNote}`);
+        }
+      }
+      if (failed.length > 0) {
+        lines.push("");
+        lines.push("## Failed");
+        for (const r of failed) {
+          lines.push(`- ${r.name} [${r.collection}]: _${r.error}_`);
+        }
+      }
+      const entryIds = created.map((r) => r.entryId);
+      if (entryIds.length > 0) {
+        lines.push("");
+        lines.push("## Next Steps");
+        lines.push(`- **Connect:** Run \`suggest-links\` on key entries to build the knowledge graph`);
+        lines.push(`- **Commit:** Use \`commit-entry\` to promote drafts to SSOT`);
+        lines.push(`- **Quality:** Run \`quality-check\` on individual entries to assess completeness`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "quality-check",
+    {
+      title: "Quality Check",
+      description: "Score an existing knowledge entry against collection-specific quality criteria. Returns a scorecard (X/10) with specific, actionable suggestions for improvement \u2014 including concrete link suggestions from graph analysis when relations are missing.\n\nChecks: name clarity, description completeness, relation connectedness, and collection-specific fields.\n\nUse after creating entries to assess their quality, or to audit existing entries.",
+      inputSchema: {
+        entryId: z.string().describe("Entry ID to check, e.g. 'TEN-graph-db', 'GT-019', 'SOS-006'")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ entryId }) => {
+      const result = await checkEntryQuality(entryId);
+      const needsRelations = result.quality.checks.some(
+        (c) => !c.passed && (c.id === "has-relations" || c.id === "diverse-relations")
+      );
+      if (needsRelations) {
+        try {
+          const suggestions = await mcpQuery("chain.graphSuggestLinks", {
+            entryId,
+            maxHops: 2,
+            limit: 3
+          });
+          if (suggestions?.suggestions?.length > 0) {
+            const linkHints = suggestions.suggestions.map((s) => `  \u2192 \`relate-entries from='${entryId}' to='${s.entryId}' type='${s.recommendedRelationType}'\` \u2014 ${s.name} [${s.collectionSlug}] (${s.score}/100)`).join("\n");
+            result.text += `
+
+## Suggested Links to Improve Quality
+${linkHints}`;
+          }
+        } catch {
+        }
+      }
+      return { content: [{ type: "text", text: result.text }] };
+    }
+  );
+}
+function extractPreview(data, maxLen) {
+  if (!data || typeof data !== "object") return "";
+  const raw = data.description ?? data.canonical ?? data.detail ?? data.rule ?? "";
+  if (typeof raw !== "string" || !raw) return "";
+  return raw.length > maxLen ? raw.substring(0, maxLen) + "..." : raw;
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "but",
+  "not",
+  "you",
+  "all",
+  "can",
+  "has",
+  "her",
+  "was",
+  "one",
+  "our",
+  "out",
+  "day",
+  "had",
+  "hot",
+  "how",
+  "its",
+  "may",
+  "new",
+  "now",
+  "old",
+  "see",
+  "way",
+  "who",
+  "did",
+  "get",
+  "let",
+  "say",
+  "she",
+  "too",
+  "use",
+  "from",
+  "have",
+  "been",
+  "each",
+  "that",
+  "this",
+  "with",
+  "will",
+  "they",
+  "what",
+  "when",
+  "make",
+  "like",
+  "long",
+  "look",
+  "many",
+  "some",
+  "them",
+  "than",
+  "most",
+  "only",
+  "over",
+  "such",
+  "into",
+  "also",
+  "back",
+  "just",
+  "much",
+  "must",
+  "name",
+  "very",
+  "your",
+  "after",
+  "which",
+  "their",
+  "about",
+  "would",
+  "there",
+  "should",
+  "could",
+  "other",
+  "these",
+  "first",
+  "being",
+  "those",
+  "still",
+  "where"
+]);
+async function runContradictionCheck(name, description) {
+  const warnings = [];
+  try {
+    const text = `${name} ${description}`.toLowerCase();
+    const keyTerms = text.split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS.has(w)).slice(0, 8);
+    if (keyTerms.length === 0) return warnings;
+    const searchQuery = keyTerms.slice(0, 3).join(" ");
+    const [govResults, archResults] = await Promise.all([
+      mcpQuery("chain.searchEntries", { query: searchQuery, collectionSlug: "business-rules" }),
+      mcpQuery("chain.searchEntries", { query: searchQuery, collectionSlug: "architecture" })
+    ]);
+    const allGov = [...govResults ?? [], ...archResults ?? []].slice(0, 5);
+    for (const entry of allGov) {
+      const entryText = `${entry.name} ${entry.data?.description ?? ""}`.toLowerCase();
+      const matched = keyTerms.filter((t) => entryText.includes(t));
+      if (matched.length < 2) continue;
+      let governsCount = 0;
+      try {
+        const relations = await mcpQuery("chain.listEntryRelations", {
+          entryId: entry.entryId
+        });
+        governsCount = (relations ?? []).filter((r) => r.type === "governs").length;
+      } catch {
+      }
+      warnings.push({
+        entryId: entry.entryId ?? "",
+        name: entry.name,
+        collection: entry.collectionSlug ?? "",
+        governsCount
+      });
+    }
+  } catch {
+  }
+  return warnings;
+}
+
+export {
+  runWithAuth,
+  getAgentSessionId,
+  isSessionOriented,
+  setSessionOriented,
+  startAgentSession,
+  closeAgentSession,
+  orphanAgentSession,
+  recordSessionActivity,
+  bootstrap,
+  bootstrapHttp,
+  getAuditLog,
+  mcpCall,
+  getWorkspaceId,
+  getWorkspaceContext,
+  mcpQuery,
+  mcpMutation,
+  requireWriteAccess,
+  recoverSessionState,
+  formatQualityReport,
+  checkEntryQuality,
+  registerSmartCaptureTools,
+  runContradictionCheck
+};
+//# sourceMappingURL=chunk-CXYNWTRQ.js.map