@productbrain/mcp 0.0.1-beta.8 → 0.0.1-beta.81

package/dist/chunk-G4JJNINW.js

@@ -0,0 +1,3441 @@
+import {
+  MCP_NPX_PACKAGE,
+  trackCaptureClassifierAutoRouted,
+  trackCaptureClassifierEvaluated,
+  trackCaptureClassifierFallback,
+  trackQualityVerdict,
+  trackToolCall
+} from "./chunk-RQXM3TCI.js";
+
+// src/tools/smart-capture.ts
+import { z as z2 } from "zod";
+
+// src/client.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+
+// 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,
+    workspaceGovernanceMode: 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 toolContextStore = new AsyncLocalStorage2();
+function runWithToolContext(ctx, fn) {
+  return toolContextStore.run(ctx, fn);
+}
+function getToolContext() {
+  return toolContextStore.getStore() ?? null;
+}
+var DEFAULT_CLOUD_URL = "https://trustworthy-kangaroo-277.convex.site";
+var CACHE_TTL_MS = 6e4;
+var CACHEABLE_FNS = [
+  "chain.getOrientEntries",
+  "chain.gatherContext",
+  "chain.graphGatherContext",
+  "chain.taskAwareGatherContext",
+  "chain.journeyAwareGatherContext",
+  "chain.assembleBuildContext"
+];
+function isCacheable(fn) {
+  return CACHEABLE_FNS.includes(fn);
+}
+var READ_PATTERN = /^(chain\.(get|list|search|batchGet|gather|graph|task|journey|assemble|workspace|score|absence)|chainwork\.(get|list|score)|maps\.(get|list)|gitchain\.(get|list|diff|history|runGate))/i;
+function isWrite(fn) {
+  if (fn.startsWith("agent.")) return false;
+  return !READ_PATTERN.test(fn);
+}
+var readCache = /* @__PURE__ */ new Map();
+function cacheKey(fn, args) {
+  return `${fn}:${JSON.stringify(args)}`;
+}
+function getCached(fn, args) {
+  if (!isCacheable(fn)) return void 0;
+  const key = cacheKey(fn, args);
+  const entry = readCache.get(key);
+  if (!entry || Date.now() > entry.expiresAt) {
+    if (entry) readCache.delete(key);
+    return void 0;
+  }
+  return entry.data;
+}
+function setCached(fn, args, data) {
+  if (!isCacheable(fn)) return;
+  const key = cacheKey(fn, args);
+  readCache.set(key, { data, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+function invalidateReadCache() {
+  readCache.clear();
+}
+var _stdioState = {
+  workspaceId: null,
+  workspaceSlug: null,
+  workspaceName: null,
+  workspaceCreatedAt: null,
+  workspaceGovernanceMode: 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;
+}
+function getApiKeyScope() {
+  return state().apiKeyScope;
+}
+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
+  });
+  if (s.agentSessionId) {
+    resetTouchThrottle(s.agentSessionId);
+  }
+  s.agentSessionId = result.sessionId;
+  s.apiKeyScope = result.toolsScope;
+  s.sessionOriented = false;
+  s.sessionClosed = false;
+  resetTouchThrottle(result.sessionId);
+  return result;
+}
+async function closeAgentSession() {
+  const s = state();
+  if (!s.agentSessionId) return;
+  const sessionId = s.agentSessionId;
+  try {
+    await mcpCall("agent.closeSession", {
+      sessionId,
+      status: "closed"
+    });
+  } finally {
+    resetTouchThrottle(sessionId);
+    s.sessionClosed = true;
+    s.agentSessionId = null;
+    s.sessionOriented = false;
+  }
+}
+async function orphanAgentSession() {
+  const s = state();
+  if (!s.agentSessionId) return;
+  const sessionId = s.agentSessionId;
+  try {
+    await mcpCall("agent.closeSession", {
+      sessionId,
+      status: "orphaned"
+    });
+  } catch {
+  } finally {
+    resetTouchThrottle(sessionId);
+    s.agentSessionId = null;
+    s.sessionOriented = false;
+  }
+}
+var _lastTouchAtBySession = /* @__PURE__ */ new Map();
+var TOUCH_THROTTLE_MS = 5e3;
+function touchSessionActivity() {
+  const s = state();
+  const sessionId = s.agentSessionId;
+  if (!sessionId) return;
+  const now = Date.now();
+  const lastTouchAt = _lastTouchAtBySession.get(sessionId) ?? 0;
+  if (now - lastTouchAt < TOUCH_THROTTLE_MS) return;
+  _lastTouchAtBySession.set(sessionId, now);
+  mcpCall("agent.touchSession", {
+    sessionId
+  }).catch(() => {
+  });
+}
+function resetTouchThrottle(sessionId) {
+  if (sessionId) {
+    _lastTouchAtBySession.delete(sessionId);
+    return;
+  }
+  _lastTouchAtBySession.clear();
+}
+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() {
+  process.env.CONVEX_SITE_URL ??= process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
+  const pbKey = process.env.PRODUCTBRAIN_API_KEY;
+  if (!pbKey?.startsWith("pb_sk_")) {
+    process.stderr.write(
+      "[MCP] Warning: PRODUCTBRAIN_API_KEY is not set or invalid. Tool calls will fail until a valid key is provided.\n"
+    );
+  }
+}
+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 toolCtx = getToolContext();
+  const entry = { ts, fn, workspace, status, durationMs };
+  if (errorMsg) entry.error = errorMsg;
+  if (toolCtx) entry.toolContext = toolCtx;
+  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 cached = getCached(fn, args);
+  if (cached !== void 0) {
+    return cached;
+  }
+  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",
+      signal: AbortSignal.timeout(1e4),
+      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 data = json.data;
+  if (isWrite(fn)) {
+    invalidateReadCache();
+  } else {
+    setCached(fn, args, data);
+  }
+  const s = state();
+  const TOUCH_EXCLUDED = /* @__PURE__ */ new Set([
+    "agent.touchSession",
+    "agent.startSession",
+    "agent.markOriented",
+    "agent.recordActivity",
+    "agent.recordWrapup",
+    "agent.closeSession"
+  ]);
+  if (s.agentSessionId && !TOUCH_EXCLUDED.has(fn)) {
+    touchSessionActivity();
+  }
+  return 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 ${MCP_NPX_PACKAGE} 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;
+      s.workspaceGovernanceMode = workspace.governanceMode ?? "open";
+      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,
+    governanceMode: s.workspaceGovernanceMode ?? "open"
+  };
+}
+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 requireActiveSession() {
+  const s = state();
+  if (!s.agentSessionId) {
+    throw new Error(
+      "Active session required (SOS-iszqu7). Call `session action=start` then `orient` first."
+    );
+  }
+  if (s.sessionClosed) {
+    throw new Error(
+      "Session has been closed (SOS-iszqu7). Start a new session with `session action=start`."
+    );
+  }
+  if (!s.sessionOriented) {
+    throw new Error(
+      "Orientation required before accessing build context (SOS-iszqu7). Call `orient` first."
+    );
+  }
+}
+function requireWriteAccess() {
+  const s = state();
+  if (!s.agentSessionId) {
+    throw new Error(
+      "Agent session required for write operations. Call `session action=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/knowledge-helpers.ts
+var EPISTEMIC_COLLECTIONS = /* @__PURE__ */ new Set(["insights", "assumptions"]);
+function deriveEpistemicStatus(entry) {
+  const coll = entry.collectionName?.toLowerCase();
+  if (!coll || !EPISTEMIC_COLLECTIONS.has(coll)) return null;
+  const relations = entry.relations ?? [];
+  const hasValidates = relations.some(
+    (r) => r.type === "validates" && r.direction === "incoming"
+  );
+  const hasInvalidates = relations.some(
+    (r) => r.type === "invalidates" && r.direction === "incoming"
+  );
+  const evidenceCount = relations.filter(
+    (r) => (r.type === "validates" || r.type === "invalidates") && r.direction === "incoming"
+  ).length;
+  if (coll === "assumptions") {
+    const ws2 = entry.workflowStatus;
+    if (ws2 === "invalidated" || hasInvalidates) {
+      return { level: "invalidated", reason: "Disproved by linked counter-evidence" };
+    }
+    if (ws2 === "validated" || hasValidates && ws2 !== "untested") {
+      return { level: "validated", reason: `${evidenceCount} evidence link${evidenceCount !== 1 ? "s" : ""}` };
+    }
+    if (ws2 === "testing") {
+      return { level: "testing", reason: "Experiment in progress" };
+    }
+    return { level: "untested", reason: "No evidence linked", action: 'Link evidence via `relations action=create type="validates"`' };
+  }
+  const ws = entry.workflowStatus;
+  if (ws === "validated" && hasValidates) {
+    return { level: "validated", reason: `${evidenceCount} evidence link${evidenceCount !== 1 ? "s" : ""}` };
+  }
+  if (ws === "evidenced" || hasValidates) {
+    return { level: "evidenced", reason: `${evidenceCount} evidence link${evidenceCount !== 1 ? "s" : ""}` };
+  }
+  return {
+    level: "hypothesis",
+    reason: "No linked evidence",
+    action: 'Link proof via `relations action=create type="validates"`'
+  };
+}
+function formatEpistemicLine(es) {
+  const icon = es.level === "validated" ? "\u2713" : es.level === "evidenced" ? "\u25CE" : es.level === "hypothesis" ? "\u25B3" : es.level === "untested" ? "?" : es.level === "testing" ? "\u25CE" : "\u2715";
+  const suffix = es.action ? ` ${es.action}` : "";
+  return `**Confidence:** ${icon} ${es.level} \u2014 ${es.reason}.${suffix}`;
+}
+function toEpistemicInput(entry) {
+  return {
+    collectionName: typeof entry.collectionName === "string" ? entry.collectionName : void 0,
+    workflowStatus: typeof entry.workflowStatus === "string" ? entry.workflowStatus : void 0,
+    relations: Array.isArray(entry.relations) ? entry.relations.map((r) => ({ type: r.type, direction: r.direction })) : void 0
+  };
+}
+function extractPreview(data, maxLen) {
+  if (!data || typeof data !== "object") return "";
+  const d = data;
+  const raw = d.description ?? d.canonical ?? d.detail ?? d.rule ?? "";
+  if (typeof raw !== "string" || !raw) return "";
+  return raw.length > maxLen ? raw.substring(0, maxLen) + "..." : raw;
+}
+var TOOL_NAME_MIGRATIONS = /* @__PURE__ */ new Map([
+  ["list-entries", 'entries action="list"'],
+  ["get-entry", 'entries action="get"'],
+  ["batch-get", 'entries action="batch"'],
+  ["search", 'entries action="search"'],
+  ["relate-entries", 'relations action="create"'],
+  ["batch-relate", 'relations action="batch-create"'],
+  ["find-related", 'graph action="find"'],
+  ["suggest-links", 'graph action="suggest"'],
+  ["gather-context", 'context action="gather"'],
+  ["get-build-context", 'context action="build"'],
+  ["list-collections", 'collections action="list"'],
+  ["create-collection", 'collections action="create"'],
+  ["update-collection", 'collections action="update"'],
+  ["agent-start", 'session action="start"'],
+  ["agent-close", 'session action="close"'],
+  ["agent-status", 'session action="status"'],
+  ["workspace-status", 'health action="status"'],
+  ["mcp-audit", 'health action="audit"'],
+  ["quality-check", 'quality action="check"'],
+  ["re-evaluate", 'quality action="re-evaluate"'],
+  ["list-workflows", 'workflows action="list"'],
+  ["workflow-checkpoint", 'workflows action="checkpoint"'],
+  ["wrapup", "session-wrapup"],
+  ["finish", "session-wrapup"]
+]);
+function translateStaleToolNames(text) {
+  const found = [];
+  for (const [old, current] of TOOL_NAME_MIGRATIONS) {
+    const pattern = new RegExp(`\\b${old.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
+    if (pattern.test(text)) {
+      found.push(`\`${old}\` \u2192 \`${current}\``);
+    }
+  }
+  if (found.length === 0) return null;
+  return `
+
+---
+_Tool name translations (these references use deprecated names):_
+${found.map((f) => `- ${f}`).join("\n")}`;
+}
+
+// src/tool-surface.ts
+function initToolSurface(_server) {
+}
+function trackWriteTool(_tool) {
+}
+
+// src/featureFlags.ts
+import { PostHog } from "posthog-node";
+var client = null;
+var LOCAL_OVERRIDES = {
+  // Uncomment for local dev without PostHog:
+  // "workspace-full-surface": false,
+  // "chainwork-enabled": true,
+  // "active-intelligence-shaping": true,  // ENT-59: Opus-powered investigation during shaping
+  // "capture-without-thinking": true, // BET-73: collection-optional capture classifier
+};
+function initFeatureFlags(posthogClient) {
+  if (posthogClient) {
+    client = posthogClient;
+    return;
+  }
+  const apiKey = process.env.POSTHOG_MCP_KEY || process.env.PUBLIC_POSTHOG_KEY;
+  if (!apiKey) {
+    client = null;
+    return;
+  }
+  client = new PostHog(apiKey, {
+    host: process.env.PUBLIC_POSTHOG_HOST || "https://eu.i.posthog.com",
+    flushAt: 1,
+    flushInterval: 5e3,
+    featureFlagsPollingInterval: 3e4
+  });
+}
+async function isFeatureEnabled(flag, workspaceId, workspaceSlug) {
+  if (process.env.FEATURE_KILL_SWITCH === "true") return false;
+  if (flag in LOCAL_OVERRIDES) return LOCAL_OVERRIDES[flag];
+  if (!client) return false;
+  try {
+    const primary = await client.isFeatureEnabled(flag, workspaceId, {
+      groups: { workspace: workspaceId },
+      groupProperties: {
+        workspace: {
+          workspace_id: workspaceId,
+          slug: workspaceSlug ?? ""
+        }
+      }
+    });
+    if (primary) return true;
+    if (workspaceSlug && workspaceSlug !== workspaceId) {
+      const secondary = await client.isFeatureEnabled(flag, workspaceSlug, {
+        groups: { workspace: workspaceSlug },
+        groupProperties: {
+          workspace: {
+            workspace_id: workspaceId,
+            slug: workspaceSlug
+          }
+        }
+      });
+      return secondary ?? false;
+    }
+    return primary ?? false;
+  } catch {
+    return false;
+  }
+}
+
+// src/gap-store.ts
+var SESSION_GAPS = [];
+var DEDUP_WINDOW_MS = 6e4;
+function isDuplicate(gap) {
+  const cutoff = gap.timestamp - DEDUP_WINDOW_MS;
+  return SESSION_GAPS.some(
+    (existing) => existing.query === gap.query && existing.tool === gap.tool && existing.action === gap.action && existing.timestamp >= cutoff
+  );
+}
+function recordGap(gap) {
+  const timestamped = { ...gap, timestamp: Date.now() };
+  if (isDuplicate(timestamped)) return false;
+  SESSION_GAPS.push(timestamped);
+  persistGap(gap);
+  return true;
+}
+function persistGap(gap) {
+  const sessionId = getAgentSessionId();
+  mcpMutation("gaps.record", {
+    sessionId: sessionId ?? void 0,
+    query: gap.query,
+    tool: gap.tool,
+    action: gap.action,
+    gapType: gap.gapType,
+    collectionScope: gap.collectionScope
+  }).catch(() => {
+  });
+}
+function getSessionGaps() {
+  return SESSION_GAPS;
+}
+function getTopGaps(limit = 5) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const gap of SESSION_GAPS) {
+    const key = gap.query.toLowerCase().trim();
+    const existing = counts.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      counts.set(key, { count: 1, gapType: gap.gapType });
+    }
+  }
+  return [...counts.entries()].map(([query, { count, gapType }]) => ({ query, count, gapType })).sort((a, b) => b.count - a.count).slice(0, limit);
+}
+function clearSessionGaps() {
+  SESSION_GAPS.length = 0;
+}
+function resolveGapsForEntry(entryName, entryId) {
+  mcpMutation("gaps.resolve", { entryName, entryId }).catch(() => {
+  });
+}
+
+// src/lib/collectionRoutingClassifier.ts
+var CLASSIFIER_AUTO_ROUTE_THRESHOLD = 70;
+var CLASSIFIER_AMBIGUITY_MARGIN = 15;
+var CLASSIFIABLE_COLLECTIONS = [
+  "decisions",
+  "tensions",
+  "glossary",
+  "insights",
+  "features",
+  "architecture",
+  "business-rules",
+  "tracking-events",
+  "landscape",
+  "standards",
+  "principles",
+  "assumptions"
+];
+var SIGNAL_WEIGHT = 10;
+var MIN_SCORE_FLOOR = 10;
+var MAX_MATCHES_PER_SIGNAL = 2;
+var MAX_REASON_COUNT = 3;
+var ENTRY_ID_PATTERN = /\b[A-Z]{2,}-\d+\b/g;
+var COLLECTION_SIGNALS = {
+  decisions: [
+    "decide",
+    "decision",
+    "chose",
+    "chosen",
+    "choice",
+    "resolved",
+    "we will",
+    "we should",
+    "approved",
+    "replaces",
+    "instead of",
+    "go with",
+    "criteria",
+    "adopted",
+    "reposition",
+    "scoring framework",
+    "review"
+  ],
+  tensions: [
+    "problem",
+    "issue",
+    "blocked",
+    "blocker",
+    "friction",
+    "pain",
+    "bottleneck",
+    "struggle",
+    "missing",
+    "breaks",
+    "regression",
+    "unclear",
+    "no way to",
+    "scope creep",
+    "coupled",
+    "trapped",
+    "ambiguous",
+    "no batch",
+    "undetectable",
+    "coordination gap"
+  ],
+  glossary: [
+    "definition",
+    "define",
+    "term",
+    "means",
+    "refers to",
+    "is called",
+    "vocabulary",
+    "terminology",
+    "a governance mechanism",
+    "a workspace",
+    "a tracked",
+    "the atom",
+    "the action of",
+    "the versioned",
+    "a field on",
+    "one of the",
+    "a constraint on",
+    "a hard data",
+    "a single"
+  ],
+  insights: [
+    "insight",
+    "learned",
+    "observed",
+    "trend",
+    "found that",
+    "discovery",
+    "validates",
+    "saturates",
+    "convergence",
+    "signals from",
+    "converge",
+    "tam"
+  ],
+  features: [
+    "feature",
+    "capability",
+    "user can",
+    "navigation",
+    "palette",
+    "modal",
+    "smart capture",
+    "suggest-links",
+    "command palette",
+    "auto-commit",
+    "collection-optional",
+    "organisation intelligence",
+    "consolidation"
+  ],
+  architecture: [
+    "architecture",
+    "layer",
+    "data model",
+    "infrastructure",
+    "system design",
+    "l1",
+    "l2",
+    "l3",
+    "l4",
+    "l5",
+    "l6",
+    "l7",
+    "guard infrastructure",
+    "data layer",
+    "intelligence layer",
+    "mcp layer",
+    "core layer"
+  ],
+  "business-rules": [
+    "guard",
+    "enforce",
+    "integrity",
+    "prevents",
+    "excludes",
+    "permitted",
+    "policy",
+    "feature gate",
+    "must not",
+    "only permitted",
+    "closed enum",
+    "write guard",
+    "never imports",
+    "requires active session",
+    "readiness excludes"
+  ],
+  "tracking-events": [
+    "track",
+    "tracking",
+    "analytics",
+    "trigger",
+    "posthog",
+    "instrument",
+    "fires when"
+  ],
+  landscape: [
+    "competitor",
+    "alternative tool",
+    "alternative platform",
+    "competing product",
+    "landscape",
+    "comparison"
+  ],
+  standards: [
+    "standard",
+    "convention",
+    "trunk-based",
+    "alignment-first",
+    "structured bet",
+    "system fixes",
+    "patches"
+  ],
+  principles: [
+    "we believe",
+    "principle",
+    "compounds",
+    "philosophy",
+    "simplicity compounds",
+    "trust through",
+    "evidence over",
+    "compensate for",
+    "honest by default"
+  ],
+  assumptions: [
+    "assume",
+    "assumption",
+    "hypothesis",
+    "untested",
+    "we think",
+    "we assume",
+    "needs validation"
+  ]
+};
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function countSignalMatches(text, signal) {
+  const trimmed = signal.trim().toLowerCase();
+  if (!trimmed) return 0;
+  const words = trimmed.split(/\s+/).map(escapeRegExp);
+  const pattern = `\\b${words.join("\\s+")}\\b`;
+  const regex = new RegExp(pattern, "g");
+  const matches = text.match(regex);
+  return matches?.length ?? 0;
+}
+function classifyCollection(name, description) {
+  const text = `${name} ${description}`.replace(ENTRY_ID_PATTERN, "").toLowerCase();
+  const rawScores = [];
+  for (const collection of CLASSIFIABLE_COLLECTIONS) {
+    const signals = COLLECTION_SIGNALS[collection];
+    const reasons = [];
+    let score = 0;
+    for (const signal of signals) {
+      const matches = countSignalMatches(text, signal);
+      if (matches <= 0) continue;
+      const cappedMatches = Math.min(matches, MAX_MATCHES_PER_SIGNAL);
+      score += cappedMatches * SIGNAL_WEIGHT;
+      if (reasons.length < MAX_REASON_COUNT) {
+        const capNote = matches > cappedMatches ? ` (capped at ${cappedMatches})` : "";
+        reasons.push(`matched "${signal}" x${matches}${capNote}`);
+      }
+    }
+    rawScores.push({ collection, score, reasons });
+  }
+  rawScores.sort((left, right) => right.score - left.score);
+  const top = rawScores[0];
+  const second = rawScores[1];
+  if (!top || top.score < MIN_SCORE_FLOOR) return null;
+  const margin = Math.max(0, top.score - (second?.score ?? 0));
+  if (margin === 0 && top.score <= MIN_SCORE_FLOOR) return null;
+  const baseConfidence = Math.min(90, top.score);
+  const confidence = Math.min(99, baseConfidence + Math.min(20, margin));
+  return {
+    collection: top.collection,
+    topConfidence: confidence,
+    confidence,
+    reasons: top.reasons,
+    scoreMargin: margin,
+    candidates: rawScores.filter((candidate) => candidate.score > 0).slice(0, 3).map((candidate) => ({
+      collection: candidate.collection,
+      signalScore: Math.min(99, candidate.score),
+      confidence: Math.min(99, candidate.score)
+    }))
+  };
+}
+function isClassificationAmbiguous(result) {
+  return result.scoreMargin < CLASSIFIER_AMBIGUITY_MARGIN;
+}
+
+// src/lib/resolveCollection.ts
+var HIGH_THRESHOLD = 80;
+var MEDIUM_THRESHOLD = 50;
+function getTier(confidence) {
+  if (confidence >= HIGH_THRESHOLD) return "high";
+  if (confidence >= MEDIUM_THRESHOLD) return "medium";
+  return "low";
+}
+var TYPE_HINT_COLLECTION_MAP = {
+  element: "features",
+  risk: "tensions",
+  decision: "decisions"
+};
+async function resolveCollection(params) {
+  const { name, description, typeHint } = params;
+  const llmResult = await tryLlmClassifier(name, description);
+  if (llmResult) {
+    return typeHint ? applyTypeHintBias(llmResult, typeHint) : llmResult;
+  }
+  const heuristic = classifyCollection(name, description);
+  if (heuristic) {
+    const resolved = heuristicToResolved(heuristic);
+    return typeHint ? applyTypeHintBias(resolved, typeHint) : resolved;
+  }
+  if (typeHint) {
+    const mapped = TYPE_HINT_COLLECTION_MAP[typeHint];
+    if (mapped) {
+      return {
+        collection: mapped,
+        confidence: 60,
+        tier: "medium",
+        alternatives: [],
+        classifiedBy: "heuristic",
+        reasoning: `Fallback from type hint: ${typeHint} \u2192 ${mapped}`
+      };
+    }
+  }
+  return null;
+}
+async function tryLlmClassifier(name, description) {
+  try {
+    const sessionId = getAgentSessionId();
+    const result = await mcpCall(
+      "chain.classifyCollection",
+      {
+        entryName: name,
+        entryDescription: description,
+        ...sessionId ? { agentSessionId: sessionId } : {}
+      }
+    );
+    if (!result || typeof result.collection !== "string" || typeof result.confidence !== "number") {
+      return null;
+    }
+    return {
+      collection: result.collection,
+      confidence: result.confidence,
+      tier: getTier(result.confidence),
+      alternatives: Array.isArray(result.alternatives) ? result.alternatives : [],
+      classifiedBy: "llm",
+      reasoning: typeof result.reasoning === "string" ? result.reasoning : ""
+    };
+  } catch (err) {
+    process.stderr.write(
+      `[resolveCollection] LLM classifier failed, falling back to heuristic: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function applyTypeHintBias(result, typeHint) {
+  const hintedCollection = TYPE_HINT_COLLECTION_MAP[typeHint];
+  if (!hintedCollection) return result;
+  if (result.collection === hintedCollection) {
+    const boosted = Math.min(99, result.confidence + 10);
+    return { ...result, confidence: boosted, tier: getTier(boosted) };
+  }
+  if (result.tier === "high") return result;
+  return {
+    ...result,
+    collection: hintedCollection,
+    confidence: 65,
+    tier: "medium",
+    reasoning: `Type hint '${typeHint}' overrode ${result.classifiedBy} classification (${result.collection} at ${result.confidence}%)`
+  };
+}
+function heuristicToResolved(result) {
+  return {
+    collection: result.collection,
+    confidence: result.confidence,
+    tier: getTier(result.confidence),
+    alternatives: result.candidates.slice(0, 3).map((c) => ({
+      collection: c.collection,
+      confidence: c.confidence
+    })),
+    classifiedBy: "heuristic",
+    reasoning: result.reasons.join("; ")
+  };
+}
+
+// src/envelope.ts
+import { z } from "zod";
+
+// src/errors.ts
+var GateError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GateError";
+  }
+};
+var BackendError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BackendError";
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var GATE_PATTERNS = [
+  {
+    pattern: /session required|no active.*session|call.*session.*start/i,
+    code: "SESSION_REQUIRED",
+    recovery: "Start an agent session first.",
+    action: { tool: "session", description: "Start session", parameters: { action: "start" } }
+  },
+  {
+    pattern: /session.*closed/i,
+    code: "SESSION_CLOSED",
+    recovery: "Start a new session.",
+    action: { tool: "session", description: "Start new session", parameters: { action: "start" } }
+  },
+  {
+    pattern: /orientation required|call.*orient/i,
+    code: "ORIENTATION_REQUIRED",
+    recovery: "Orient before writing.",
+    action: { tool: "orient", description: "Orient session", parameters: {} }
+  },
+  {
+    pattern: /read.?only.*scope/i,
+    code: "READONLY_SCOPE",
+    recovery: "This API key cannot write. Use a readwrite key.",
+    action: { tool: "health", description: "Check key scope", parameters: { action: "whoami" } }
+  }
+];
+function classifyError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (err instanceof GateError) {
+    return {
+      code: "PERMISSION_DENIED",
+      message,
+      recovery: "Check permissions or use a readwrite API key.",
+      availableActions: [{ tool: "health", description: "Check key scope", parameters: { action: "whoami" } }]
+    };
+  }
+  if (err instanceof BackendError) {
+    return { code: "BACKEND_ERROR", message, recovery: "Retry the operation or check backend health." };
+  }
+  if (err instanceof ValidationError) {
+    return { code: "VALIDATION_ERROR", message };
+  }
+  for (const { pattern, code, recovery, action } of GATE_PATTERNS) {
+    if (pattern.test(message)) {
+      return { code, message, recovery, availableActions: [action] };
+    }
+  }
+  if (/network error|fetch failed|ECONNREFUSED|ETIMEDOUT/i.test(message)) {
+    return { code: "BACKEND_UNAVAILABLE", message, recovery: "Retry in a few seconds." };
+  }
+  if (/not found/i.test(message)) {
+    return {
+      code: "NOT_FOUND",
+      message,
+      recovery: "Use entries action=search to find the correct ID.",
+      availableActions: [{ tool: "entries", description: "Search entries", parameters: { action: "search" } }]
+    };
+  }
+  if (/duplicate|already exists/i.test(message)) {
+    return {
+      code: "DUPLICATE",
+      message,
+      recovery: "Use entries action=get to inspect the existing entry.",
+      availableActions: [{ tool: "entries", description: "Get entry", parameters: { action: "get" } }]
+    };
+  }
+  if (/invalid|validation|required field/i.test(message)) {
+    return { code: "VALIDATION_ERROR", message };
+  }
+  return { code: "INTERNAL_ERROR", message: message || "An unexpected error occurred." };
+}
+
+// src/envelope.ts
+function success(summary, data, next) {
+  return {
+    ok: true,
+    summary: summary || "Operation completed.",
+    data,
+    ...next?.length ? { next } : {}
+  };
+}
+function failure(code, message, recovery, availableActions, diagnostics) {
+  return {
+    ok: false,
+    code,
+    message,
+    ...recovery ? { recovery } : {},
+    ...availableActions?.length ? { availableActions } : {},
+    ...diagnostics ? { diagnostics } : {}
+  };
+}
+function notFound(id, hint) {
+  return failure(
+    "NOT_FOUND",
+    `Entry '${id}' not found.`,
+    hint ?? "Use entries action=search to find the correct ID.",
+    [{ tool: "entries", description: "Search entries", parameters: { action: "search", query: id } }]
+  );
+}
+function validationError(message) {
+  return failure("VALIDATION_ERROR", message);
+}
+function textContent(text) {
+  return [{ type: "text", text }];
+}
+function parseOrFail(schema, args) {
+  const parsed = schema.safeParse(args);
+  if (parsed.success) return { ok: true, data: parsed.data };
+  const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+  const msg = `Invalid arguments: ${issues}`;
+  return {
+    ok: false,
+    result: { content: textContent(msg), structuredContent: validationError(msg) }
+  };
+}
+function unknownAction(action, valid) {
+  const msg = `Unknown action '${action}'. Valid actions: ${valid.join(", ")}.`;
+  return { content: textContent(msg), structuredContent: validationError(msg) };
+}
+function successResult(text, summary, data, next) {
+  return { content: textContent(text), structuredContent: success(summary, data, next) };
+}
+function failureResult(text, code, message, recovery, availableActions, diagnostics) {
+  return { content: textContent(text), structuredContent: failure(code, message, recovery, availableActions, diagnostics) };
+}
+function notFoundResult(id, text, hint) {
+  return { content: textContent(text ?? `Entry '${id}' not found.`), structuredContent: notFound(id, hint) };
+}
+function validationResult(message) {
+  return { content: textContent(message), structuredContent: validationError(message) };
+}
+var nextActionSchema = z.object({
+  tool: z.string(),
+  description: z.string(),
+  parameters: z.record(z.unknown())
+});
+var metaSchema = z.object({
+  durationMs: z.number().optional()
+}).optional();
+function withEnvelope(handler) {
+  return async (args) => {
+    const start = Date.now();
+    try {
+      const result = await handler(args);
+      const durationMs = Date.now() - start;
+      const sc = result.structuredContent;
+      if (sc && typeof sc === "object" && "ok" in sc) {
+        sc._meta = { ...sc._meta, durationMs };
+        return {
+          content: result.content ?? [],
+          structuredContent: sc,
+          ...sc.ok === false ? { isError: true } : {}
+        };
+      }
+      console.warn(`[withEnvelope] Handler returned without envelope shape. Wrapping automatically. Content preview: "${result.content?.[0]?.text?.slice(0, 60) ?? "(empty)"}"`);
+      return {
+        content: result.content ?? [],
+        structuredContent: {
+          ...success(
+            result.content?.[0]?.text?.slice(0, 100) ?? "",
+            sc ?? {}
+          ),
+          _meta: { durationMs }
+        }
+      };
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      const classified = classifyError(err);
+      const envelope = {
+        ...failure(
+          classified.code,
+          classified.message,
+          classified.recovery,
+          classified.availableActions
+        ),
+        _meta: { durationMs }
+      };
+      return {
+        content: [{ type: "text", text: classified.message }],
+        structuredContent: envelope,
+        isError: true
+      };
+    }
+  };
+}
+
+// src/lib/fieldTypes.ts
+var FIELD_TYPE_DEFAULTS = {
+  "string": "",
+  "text": "",
+  "rich-text": "",
+  "number": null,
+  "boolean": false,
+  "select": null,
+  "multi-select": [],
+  "array": [],
+  "json": null
+};
+
+// src/tools/smart-capture-routing.ts
+var STARTER_COLLECTIONS = CLASSIFIABLE_COLLECTIONS;
+
+// 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 `graph action=suggest` and `relations action=create` 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 STRATEGY_CATEGORY_INFERENCE_THRESHOLD = 2;
+var STRATEGY_CATEGORY_SIGNALS = [
+  ["business-model", [/pricing/, /revenue/, /unit economics/, /cost structure/, /monetiz/, /margin/, /per.?seat/, /subscription/, /freemium/]],
+  ["vision", [/vision/, /aspirational/, /future state/, /world where/]],
+  ["purpose", [/purpose/, /why we exist/, /mission/, /reason for being/]],
+  ["goal", [/goal/, /metric/, /target/, /kpi/, /okr/, /critical number/, /measur/]],
+  ["principle", [/we believe/, /guiding principle/, /core belief/, /philosophy/]],
+  ["product-area", [/product area/, /module/, /surface/, /capability area/]],
+  ["audience", [/audience/, /persona/, /user segment/, /icp/, /target market/]],
+  ["insight", [/insight/, /we learned/, /we observed/, /pattern/]],
+  ["opportunity", [/opportunity/, /whitespace/, /gap/, /underserved/]]
+];
+function inferStrategyCategory(name, description) {
+  const text = `${name} ${description}`.toLowerCase();
+  let bestCategory = null;
+  let bestScore = 0;
+  for (const [cat, signals] of STRATEGY_CATEGORY_SIGNALS) {
+    const score = signals.reduce((s, rx) => s + (rx.test(text) ? 1 : 0), 0);
+    if (score > bestScore) {
+      bestScore = score;
+      bestCategory = cat;
+    }
+  }
+  if (bestCategory && bestScore >= STRATEGY_CATEGORY_INFERENCE_THRESHOLD) return bestCategory;
+  if (bestScore === 0) return "strategy";
+  return null;
+}
+var PROFILES = /* @__PURE__ */ new Map([
+  ["tensions", {
+    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", {
+    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", {
+    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", {
+    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", {
+    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", {
+    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", {
+    governedDraft: true,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["informs", "governs", "belongs_to", "related_to"],
+    inferField: (ctx) => {
+      if (ctx.data?.category) return {};
+      const category = inferStrategyCategory(ctx.name, ctx.description);
+      return category ? { category } : {};
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      COMMON_CHECKS.diverseRelations
+    ]
+  }],
+  ["maps", {
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["fills_slot", "references", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription
+    ]
+  }],
+  ["chains", {
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["informs", "references", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription
+    ]
+  }],
+  ["principles", {
+    governedDraft: true,
+    descriptionField: "description",
+    defaults: [
+      { key: "severity", value: "high" },
+      { key: "category", value: "infer" }
+    ],
+    recommendedRelationTypes: ["governs", "informs", "references", "related_to"],
+    inferField: (ctx) => {
+      const fields = {};
+      const area = inferArea(`${ctx.name} ${ctx.description}`);
+      if (area) {
+        const categoryMap = {
+          "Architecture": "Engineering",
+          "Chain": "Product",
+          "AI & MCP Integration": "Engineering",
+          "Developer Experience": "Engineering",
+          "Governance & Decision-Making": "Business",
+          "Analytics & Tracking": "Product",
+          "Security": "Engineering"
+        };
+        fields.category = categoryMap[area] ?? "Product";
+      }
+      return fields;
+    },
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-rationale",
+        label: "Rationale provided \u2014 why this principle matters",
+        check: (ctx) => typeof ctx.data.rationale === "string" && ctx.data.rationale.length > 20,
+        suggestion: () => "Explain why this principle exists and what goes wrong without it."
+      }
+    ]
+  }],
+  ["standards", {
+    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", {
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["references", "belongs_to", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription
+    ]
+  }],
+  ["insights", {
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [
+      { key: "evidenceStrength", value: "anecdotal" }
+    ],
+    recommendedRelationTypes: ["validates", "invalidates", "informs", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-evidence-link",
+        label: "Evidence link exists (validates or invalidates)",
+        check: (ctx) => ctx.linksCreated.some((l) => l.relationType === "validates" || l.relationType === "invalidates"),
+        suggestion: () => "Link this insight to the assumption or claim it validates/invalidates using `relations action=create type=validates`."
+      },
+      {
+        id: "has-source",
+        label: "Source documented",
+        check: (ctx) => !!ctx.data?.source && String(ctx.data.source).length > 0,
+        suggestion: () => "Document where this insight came from (research, data, user interview, etc.)."
+      }
+    ]
+  }],
+  ["assumptions", {
+    governedDraft: false,
+    descriptionField: "belief",
+    defaults: [
+      { key: "risk", value: "medium" },
+      { key: "evidenceStrength", value: "unvalidated" }
+    ],
+    recommendedRelationTypes: ["depends_on", "informs", "related_to", "validates", "invalidates"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      {
+        id: "has-belief",
+        label: "Belief statement provided (>30 chars)",
+        check: (ctx) => !!ctx.data?.belief && String(ctx.data.belief).length > 30,
+        suggestion: () => "Write the assumption as a clear, testable belief statement."
+      },
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-test-method",
+        label: "Test method described",
+        check: (ctx) => !!ctx.data?.testMethod && String(ctx.data.testMethod).length > 0,
+        suggestion: () => "Describe how this assumption could be tested or validated."
+      }
+    ]
+  }],
+  ["architecture", {
+    governedDraft: true,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["belongs_to", "depends_on", "governs", "references", "related_to"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType,
+      {
+        id: "has-layer",
+        label: "Architecture layer identified",
+        check: (ctx) => !!ctx.data?.layer && String(ctx.data.layer).length > 0,
+        suggestion: () => "Specify which architecture layer this belongs to (L1-L7)."
+      }
+    ]
+  }],
+  ["landscape", {
+    governedDraft: false,
+    descriptionField: "description",
+    defaults: [],
+    recommendedRelationTypes: ["references", "related_to", "fills_slot"],
+    qualityChecks: [
+      COMMON_CHECKS.clearName,
+      COMMON_CHECKS.hasDescription,
+      COMMON_CHECKS.hasRelations,
+      COMMON_CHECKS.hasType
+    ]
+  }]
+]);
+var FALLBACK_PROFILE = {
+  governedDraft: false,
+  descriptionField: "description",
+  defaults: [],
+  recommendedRelationTypes: ["related_to", "references"],
+  qualityChecks: [
+    COMMON_CHECKS.clearName,
+    COMMON_CHECKS.hasDescription,
+    COMMON_CHECKS.hasRelations,
+    COMMON_CHECKS.hasType
+  ]
+};
+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;
+  const reasons = [];
+  if (text.includes(candidateName) && candidateName.length > 3) {
+    score += 40;
+    reasons.push("name match");
+  }
+  const candidateWords = candidateName.split(/\s+/).filter((w) => w.length > 3);
+  const matchingWords = candidateWords.filter((w) => text.includes(w));
+  const wordScore = matchingWords.length / Math.max(candidateWords.length, 1) * 30;
+  score += wordScore;
+  if (matchingWords.length > 0) {
+    reasons.push(`word overlap (${matchingWords.slice(0, 3).join(", ")})`);
+  }
+  const HUB_COLLECTIONS = /* @__PURE__ */ new Set(["strategy", "features"]);
+  if (HUB_COLLECTIONS.has(candidateCollection)) {
+    score += 15;
+    reasons.push("hub collection");
+  }
+  if (candidateCollection !== sourceCollection) {
+    score += 10;
+    reasons.push("cross-collection");
+  }
+  const finalScore = Math.min(score, 100);
+  const reason = reasons.length > 0 ? reasons.join(" + ") : "low relevance";
+  return { score: finalScore, reason };
+}
+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"
+    }
+  };
+  const mapped = typeMap[sourceCollection]?.[targetCollection];
+  const type = mapped ?? profile.recommendedRelationTypes[0] ?? "related_to";
+  const reason = mapped ? `collection pair (${sourceCollection} \u2192 ${targetCollection})` : `profile default (${profile.recommendedRelationTypes[0] ?? "related_to"})`;
+  return { type, reason };
+}
+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 failed = result.checks.filter((c) => !c.passed);
+  const reason = failed.length > 0 ? ` because ${failed.map((c) => c.suggestion ?? c.label.toLowerCase()).join("; ")}` : "";
+  const lines = [`## Quality: ${result.score}/${result.maxScore}${reason}`];
+  for (const check of result.checks) {
+    const icon = check.passed ? "[x]" : "[ ]";
+    const suggestion = check.passed ? "" : ` \u2014 ${check.suggestion ?? check.label}`;
+    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 \`relations action=create\` to add connections._`);
+    }
+  }
+  return { text: lines.join("\n"), quality };
+}
+var GOVERNED_COLLECTIONS = /* @__PURE__ */ new Set([
+  "glossary",
+  "business-rules",
+  "principles",
+  "standards",
+  "strategy",
+  "features",
+  "architecture"
+]);
+var AUTO_LINK_CONFIDENCE_THRESHOLD = 35;
+var MAX_AUTO_LINKS = 5;
+var MAX_SUGGESTIONS = 5;
+var CAPTURE_WITHOUT_THINKING_FLAG = "capture-without-thinking";
+var BR_STD_ENTRY_ID_REGEX = /^(BR|STD)-\d+$/;
+var entryIdSchema = z2.string().regex(BR_STD_ENTRY_ID_REGEX).optional().describe(
+  "Only for business-rules and standards. Must match BR-NNN or STD-NNN. Omit for all other collections \u2014 IDs are auto-generated."
+);
+var captureSchema = z2.object({
+  collection: z2.string().optional().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional when `capture-without-thinking` is enabled."),
+  name: z2.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
+  description: z2.string().describe("Full context \u2014 what's happening, why it matters, what you observed"),
+  context: z2.string().optional().describe("Optional additional context (e.g. 'Observed during context gather calls taking 700ms+')"),
+  entryId: entryIdSchema,
+  canonicalKey: z2.string().optional().describe("Semantic type (e.g. 'decision', 'tension', 'vision'). Auto-assigned from collection if omitted."),
+  data: z2.record(z2.unknown()).optional().describe("Explicit field values when you know the schema (e.g. canonical_key, cardinality_rule, required_fields). Merged with inferred values; user-provided wins."),
+  links: z2.array(z2.object({
+    to: z2.string().describe("Target entry ID (e.g. 'BR-64', 'ARCH-8')"),
+    type: z2.string().describe("Relation type (e.g. 'governs', 'related_to', 'informs')")
+  })).optional().describe("Relations to create after capture. Skips auto-link discovery when provided."),
+  autoCommit: z2.boolean().optional().describe(
+    "If true, commits the entry immediately after capture + linking. If omitted, Open mode workspaces auto-commit by default and consensus/role modes stay draft-first."
+  )
+});
+var batchCaptureSchema = z2.object({
+  entries: z2.array(z2.object({
+    collection: z2.string().optional().describe("Collection slug. Optional \u2014 auto-classified via LLM when omitted (FEAT-160)."),
+    name: z2.string().describe("Display name"),
+    description: z2.string().describe("Full context / definition"),
+    entryId: entryIdSchema
+  })).min(1).max(50).describe("Array of entries to capture"),
+  autoCommit: z2.boolean().optional().describe(
+    "If true, commits created entries immediately after linking. If omitted, Open mode workspaces commit by default and consensus/role modes stay draft-first."
+  )
+});
+var captureClassifierSchema = z2.object({
+  enabled: z2.boolean(),
+  autoRouted: z2.boolean(),
+  agrees: z2.boolean(),
+  abstained: z2.boolean(),
+  topConfidence: z2.number(),
+  confidence: z2.number(),
+  reasons: z2.array(z2.string()),
+  candidates: z2.array(
+    z2.object({
+      collection: z2.string(),
+      signalScore: z2.number().optional(),
+      confidence: z2.number()
+    })
+  ),
+  agentProvidedCollection: z2.string().optional(),
+  overrideCommand: z2.string().optional(),
+  classifiedBy: z2.enum(["llm", "heuristic", "explicit"]).optional(),
+  confidenceTier: z2.enum(["high", "medium", "low"]).optional(),
+  reasoning: z2.string().optional()
+});
+function trackClassifierTelemetry(params) {
+  const telemetry = {
+    predicted_collection: params.predictedCollection,
+    confidence: params.confidence,
+    auto_routed: params.autoRouted,
+    reason_category: params.reasonCategory,
+    explicit_collection_provided: params.explicitCollectionProvided
+  };
+  trackCaptureClassifierEvaluated(params.workspaceId, telemetry);
+  if (params.outcome === "auto-routed") {
+    trackCaptureClassifierAutoRouted(params.workspaceId, telemetry);
+    return;
+  }
+  trackCaptureClassifierFallback(params.workspaceId, telemetry);
+}
+function buildCollectionRequiredResult() {
+  return {
+    content: [{
+      type: "text",
+      text: "Collection is required unless `capture-without-thinking` is enabled.\n\nProvide `collection` explicitly, or enable the feature flag for this workspace."
+    }],
+    structuredContent: failure(
+      "VALIDATION_ERROR",
+      "Collection is required unless capture-without-thinking is enabled.",
+      "Provide collection explicitly, or enable the feature flag.",
+      [{ tool: "collections", description: "List available collections", parameters: { action: "list" } }]
+    )
+  };
+}
+function buildClassifierUnknownResult() {
+  return {
+    content: [{
+      type: "text",
+      text: "I could not infer a collection confidently from this input.\n\nPlease provide `collection`, or rewrite with clearer intent (decision/problem/definition/insight/bet)."
+    }],
+    structuredContent: failure(
+      "VALIDATION_ERROR",
+      "Could not infer collection from input.",
+      "Provide collection explicitly, or rewrite with clearer intent.",
+      [{ tool: "collections", description: "List available collections", parameters: { action: "list" } }],
+      { classifier: { enabled: true, autoRouted: false, agrees: false, abstained: true, topConfidence: 0, confidence: 0, reasons: [], candidates: [] } }
+    )
+  };
+}
+function buildLowConfidenceResult(resolved, classifierMeta) {
+  const allCandidates = [
+    { collection: resolved.collection, confidence: resolved.confidence },
+    ...resolved.alternatives
+  ];
+  const suggestions = allCandidates.map((c) => `- \`${c.collection}\` (${c.confidence}% confidence)`).join("\n");
+  const textBody = `Low confidence classification (${resolved.confidence}%, classified by ${resolved.classifiedBy}).
+
+Predicted: \`${resolved.collection}\`
+Reason: ${resolved.reasoning || "low signal"}
+
+Choose one of these and retry with \`collection\`:
+${suggestions}
+
+Correction path: rerun with your chosen \`collection\`, or capture and use \`entries action=move\` later.`;
+  return {
+    content: [{ type: "text", text: textBody }],
+    structuredContent: failure(
+      "VALIDATION_ERROR",
+      `Low confidence routing to '${resolved.collection}' (${resolved.confidence}%, ${resolved.classifiedBy}).`,
+      "Rerun with explicit collection.",
+      allCandidates.map((c) => ({
+        tool: "capture",
+        description: `Capture to ${c.collection}`,
+        parameters: { collection: c.collection }
+      })),
+      { classifier: classifierMeta }
+    )
+  };
+}
+function buildClassifierMeta(resolved, overrides = {}) {
+  return {
+    enabled: true,
+    autoRouted: false,
+    agrees: true,
+    abstained: false,
+    topConfidence: resolved.confidence,
+    confidence: resolved.confidence,
+    reasons: resolved.reasoning ? [resolved.reasoning] : [],
+    candidates: [
+      { collection: resolved.collection, confidence: resolved.confidence },
+      ...resolved.alternatives.map((a) => ({ collection: a.collection, confidence: a.confidence }))
+    ].slice(0, 3),
+    classifiedBy: resolved.classifiedBy,
+    confidenceTier: resolved.tier,
+    reasoning: resolved.reasoning,
+    ...overrides
+  };
+}
+async function resolveCaptureCollection(params) {
+  const {
+    collection,
+    name,
+    description,
+    classifierFlagOn,
+    workspaceId,
+    explicitCollectionProvided
+  } = params;
+  if (collection) {
+    const resolved2 = await resolveCollection({ name, description });
+    if (resolved2) {
+      const agrees = resolved2.collection === collection;
+      const classifierMeta2 = buildClassifierMeta(resolved2, {
+        autoRouted: false,
+        agrees,
+        agentProvidedCollection: collection,
+        ...!agrees && {
+          overrideCommand: `capture collection="${resolved2.collection}"`
+        }
+      });
+      if (!agrees) {
+        trackClassifierTelemetry({
+          workspaceId,
+          predictedCollection: resolved2.collection,
+          confidence: resolved2.confidence,
+          autoRouted: false,
+          reasonCategory: "low-confidence",
+          explicitCollectionProvided: true,
+          outcome: "fallback"
+        });
+      }
+      return { resolvedCollection: collection, classifierMeta: classifierMeta2 };
+    }
+    return {
+      resolvedCollection: collection,
+      classifierMeta: {
+        enabled: true,
+        autoRouted: false,
+        agrees: false,
+        abstained: true,
+        topConfidence: 0,
+        confidence: 0,
+        reasons: [],
+        candidates: [],
+        agentProvidedCollection: collection
+      }
+    };
+  }
+  if (!classifierFlagOn) {
+    return { earlyResult: buildCollectionRequiredResult() };
+  }
+  const resolved = await resolveCollection({ name, description });
+  if (!resolved) {
+    trackClassifierTelemetry({
+      workspaceId,
+      predictedCollection: "unknown",
+      confidence: 0,
+      autoRouted: false,
+      reasonCategory: "low-confidence",
+      explicitCollectionProvided,
+      outcome: "fallback"
+    });
+    return { earlyResult: buildClassifierUnknownResult() };
+  }
+  const autoRoute = resolved.tier !== "low";
+  const classifierMeta = buildClassifierMeta(resolved, { autoRouted: autoRoute });
+  if (!autoRoute) {
+    trackClassifierTelemetry({
+      workspaceId,
+      predictedCollection: resolved.collection,
+      confidence: resolved.confidence,
+      autoRouted: false,
+      reasonCategory: "low-confidence",
+      explicitCollectionProvided,
+      outcome: "fallback"
+    });
+    return {
+      classifierMeta,
+      earlyResult: buildLowConfidenceResult(resolved, classifierMeta)
+    };
+  }
+  trackClassifierTelemetry({
+    workspaceId,
+    predictedCollection: resolved.collection,
+    confidence: resolved.confidence,
+    autoRouted: true,
+    reasonCategory: "auto-routed",
+    explicitCollectionProvided,
+    outcome: "auto-routed"
+  });
+  return {
+    resolvedCollection: resolved.collection,
+    classifierMeta
+  };
+}
+var captureSuccessOutputSchema = z2.object({
+  entryId: z2.string(),
+  collection: z2.string(),
+  name: z2.string(),
+  status: z2.enum(["draft", "committed", "proposed"]),
+  qualityScore: z2.number(),
+  qualityVerdict: z2.record(z2.unknown()).optional(),
+  classifier: captureClassifierSchema.optional(),
+  studioUrl: z2.string().optional(),
+  warnings: z2.array(z2.string()).optional(),
+  normalization: z2.object({
+    remapped: z2.record(z2.string()).optional(),
+    rejected: z2.array(z2.string()).optional()
+  }).optional(),
+  expectedFields: z2.array(z2.object({
+    key: z2.string(),
+    type: z2.string(),
+    required: z2.boolean().optional()
+  })).optional()
+}).strict();
+var captureClassifierOnlyOutputSchema = z2.object({
+  classifier: captureClassifierSchema
+}).strict();
+var captureOutputSchema = z2.union([
+  captureSuccessOutputSchema,
+  captureClassifierOnlyOutputSchema
+]);
+var batchCaptureOutputSchema = z2.object({
+  captured: z2.array(z2.object({
+    entryId: z2.string(),
+    collection: z2.string(),
+    name: z2.string(),
+    status: z2.enum(["draft", "committed", "proposed"]),
+    classifiedBy: z2.enum(["llm", "heuristic", "explicit"]).optional(),
+    confidence: z2.number().optional(),
+    confidenceTier: z2.enum(["high", "medium", "low"]).optional(),
+    warnings: z2.array(z2.string()).optional(),
+    normalization: z2.object({
+      remapped: z2.record(z2.string()).optional(),
+      rejected: z2.array(z2.string()).optional()
+    }).optional()
+  })),
+  total: z2.number(),
+  failed: z2.number(),
+  committed: z2.number(),
+  proposed: z2.number(),
+  drafts: z2.number(),
+  classified: z2.number().optional(),
+  autoCommitApplied: z2.boolean(),
+  skippedLowConfidence: z2.array(z2.object({
+    index: z2.number(),
+    name: z2.string(),
+    suggestedCollection: z2.string().optional(),
+    confidence: z2.number().optional(),
+    alternatives: z2.array(z2.object({
+      collection: z2.string(),
+      confidence: z2.number()
+    })).optional()
+  })).optional(),
+  failedEntries: z2.array(z2.object({
+    index: z2.number(),
+    collection: z2.string(),
+    name: z2.string(),
+    error: z2.string()
+  })).optional()
+});
+function shouldAutoCommitCapture(autoCommit, governanceMode) {
+  return autoCommit === true || autoCommit === void 0 && governanceMode === "open";
+}
+function buildDataFromFields(fields, descriptionField, descriptionValue) {
+  const data = {};
+  for (const field of fields) {
+    if (field.key === descriptionField) {
+      data[field.key] = descriptionValue;
+    } else {
+      data[field.key] = FIELD_TYPE_DEFAULTS[field.type] ?? null;
+    }
+  }
+  return data;
+}
+function registerSmartCaptureTools(server) {
+  const captureTool = 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 name and description; `collection` is optional when `capture-without-thinking` is enabled.\n\nSupported collections with smart profiles: tensions, business-rules, glossary, decisions, features, audiences, strategy, standards, maps, chains, insights, assumptions, principles, tracking-events.\nAll other collections get an ENT-{random} ID and sensible defaults.\n\n**Explicit data:** When you know the schema, pass `data: { field: value }` to set fields directly. Top-level `name` and `description` always win for those fields. `data` wins over inference for all other fields.\n\n**Compound capture:** Pass `links` to create relations in the same call (skips auto-link discovery). In Open mode, entries commit by default when `autoCommit` is omitted. Pass `autoCommit: true` to promote the entry from draft to SSOT immediately after linking when you want to be explicit. Governed collections (glossary, business-rules, principles, standards, strategy, features, architecture) will warn but still commit \u2014 use only when you're certain.\n\nEntries are created as `draft` first, then may publish immediately depending on governance and `autoCommit`. Use `update-entry` for post-creation adjustments.",
+      inputSchema: captureSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    withEnvelope(async ({ collection, name, description, context, entryId, canonicalKey, data: userData, links, autoCommit }) => {
+      requireWriteAccess();
+      const wsCtx = await getWorkspaceContext();
+      const explicitCollectionProvided = typeof collection === "string" && collection.trim().length > 0;
+      const classifierFlagOn = await isFeatureEnabled(
+        CAPTURE_WITHOUT_THINKING_FLAG,
+        wsCtx.workspaceId,
+        wsCtx.workspaceSlug
+      );
+      const resolution = await resolveCaptureCollection({
+        collection,
+        name,
+        description,
+        classifierFlagOn,
+        workspaceId: wsCtx.workspaceId,
+        explicitCollectionProvided
+      });
+      if (resolution.earlyResult) {
+        return resolution.earlyResult;
+      }
+      let resolvedCollection = resolution.resolvedCollection;
+      const classifierMeta = resolution.classifierMeta;
+      if (!resolvedCollection) {
+        return buildCollectionRequiredResult();
+      }
+      if (entryId && resolvedCollection !== "business-rules" && resolvedCollection !== "standards") {
+        return {
+          content: [{
+            type: "text",
+            text: `# BR-111: entryId Not Allowed
+
+\`entryId\` is only valid for \`business-rules\` and \`standards\` collections. For \`${resolvedCollection}\`, omit \`entryId\` \u2014 IDs are auto-generated.`
+          }],
+          structuredContent: failure(
+            "INVALID_ENTRY_ID",
+            `entryId is only allowed for business-rules and standards. Omit for ${resolvedCollection}.`,
+            "Remove entryId from your capture call.",
+            []
+          )
+        };
+      }
+      const profile = PROFILES.get(resolvedCollection) ?? FALLBACK_PROFILE;
+      const col = await mcpQuery("chain.getCollection", { slug: resolvedCollection });
+      if (!col) {
+        const displayName = resolvedCollection.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+        return {
+          content: [{
+            type: "text",
+            text: `Collection \`${resolvedCollection}\` not found.
+
+**To create it**, run:
+\`\`\`
+collections action=create slug="${resolvedCollection}" name="${displayName}" description="..."
+\`\`\`
+
+Or use \`collections action=list\` to see available collections.`
+          }],
+          structuredContent: failure(
+            "NOT_FOUND",
+            `Collection '${resolvedCollection}' not found.`,
+            "Create the collection first, or use collections action=list to see available ones.",
+            [
+              { tool: "collections", description: "Create collection", parameters: { action: "create", slug: resolvedCollection, name: displayName } },
+              { tool: "collections", description: "List collections", parameters: { action: "list" } }
+            ]
+          )
+        };
+      }
+      const data = buildDataFromFields(col.fields ?? [], profile.descriptionField, description);
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      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: resolvedCollection,
+          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 (userData && typeof userData === "object") {
+        for (const [key, val] of Object.entries(userData)) {
+          if (key !== "name") data[key] = val;
+        }
+      }
+      data[profile.descriptionField || "description"] = description;
+      const isBetCapture = canonicalKey === "bet";
+      if (isBetCapture) {
+        data.chainTypeId = "bet";
+        const betContentFields = ["problem", "appetite", "elements", "architecture", "rabbitHoles", "noGos", "doneWhen", "buildSequence", "buildContract", "solution"];
+        const betLinks = {};
+        for (const field of betContentFields) {
+          if (data[field] !== void 0) {
+            betLinks[field] = data[field];
+            delete data[field];
+          }
+        }
+        data.links = betLinks;
+      }
+      const E2_LLM_REMAP_ENABLED = false;
+      const payloadForPreview = E2_LLM_REMAP_ENABLED && userData && typeof userData === "object" ? { ...data } : null;
+      if (payloadForPreview) {
+        try {
+          const preview = await mcpCall(
+            "chain.normalizeEntryDataPreview",
+            { collectionSlug: resolvedCollection, data: payloadForPreview }
+          );
+          const rejected = (preview?.rejected ?? []).filter((k) => k !== "name");
+          if (rejected.length > 0) {
+            const llmResult = await mcpCall(
+              "chain.normalizeEntryDataLLM",
+              {
+                collectionSlug: resolvedCollection,
+                unknownKeys: rejected,
+                data: payloadForPreview
+              }
+            );
+            if (llmResult && Object.keys(llmResult.remapped).length > 0) {
+              const fieldKeySet = new Set((col.fields ?? []).map((f) => f.key));
+              for (const [oldKey, newKey] of Object.entries(llmResult.remapped)) {
+                if (data[oldKey] !== void 0 && !fieldKeySet.has(oldKey)) {
+                  data[newKey] = data[oldKey];
+                  delete data[oldKey];
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      const status = "draft";
+      const agentId = getAgentSessionId();
+      let finalEntryId;
+      let internalId;
+      let entryWarnings = [];
+      let normalizationMeta;
+      try {
+        const result = await mcpMutation("chain.createEntry", {
+          collectionSlug: resolvedCollection,
+          entryId: entryId ?? void 0,
+          name,
+          status,
+          data,
+          canonicalKey,
+          createdBy: agentId ? `agent:${agentId}` : "capture",
+          sessionId: agentId ?? void 0
+        });
+        internalId = result.docId;
+        finalEntryId = result.entryId;
+        entryWarnings = result.warnings ?? [];
+        normalizationMeta = result.normalization;
+        resolveGapsForEntry(name, result.entryId);
+      } 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 \`entries action=get\` to inspect the existing entry, or \`update-entry\` to modify it.`
+            }],
+            structuredContent: failure(
+              "DUPLICATE",
+              msg,
+              "Use entries action=get to inspect the existing entry.",
+              [
+                { tool: "entries", description: "Get existing entry", parameters: { action: "get", entryId: entryId ?? name } },
+                { tool: "update-entry", description: "Update existing entry", parameters: { entryId: entryId ?? "" } }
+              ]
+            )
+          };
+        }
+        throw error;
+      }
+      const linksCreated = [];
+      const linksSuggested = [];
+      const userLinkResults = [];
+      const pendingRelations = [];
+      const skipAutoDiscovery = links && links.length > 0;
+      const searchQuery = extractSearchTerms(name, description);
+      if (searchQuery && !skipAutoDiscovery) {
+        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) => {
+          const conf = computeLinkConfidence(r, name, description, resolvedCollection, collMap.get(r.collectionId) ?? "unknown");
+          return {
+            ...r,
+            collSlug: collMap.get(r.collectionId) ?? "unknown",
+            confidence: conf.score,
+            confidenceReason: conf.reason
+          };
+        }).sort((a, b) => b.confidence - a.confidence);
+        let autoCount = 0;
+        for (const c of candidates) {
+          if (autoCount >= MAX_AUTO_LINKS) break;
+          if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
+          if (!c.entryId || !finalEntryId) continue;
+          const { type: relationType, reason: relationReason } = inferRelationType(resolvedCollection, c.collSlug, profile);
+          pendingRelations.push({
+            fromEntryId: finalEntryId,
+            toEntryId: c.entryId,
+            type: relationType,
+            meta: {
+              source: "auto",
+              targetName: c.name,
+              targetCollection: c.collSlug,
+              linkReason: `confidence ${c.confidence} (${c.confidenceReason}) + ${relationReason}`
+            }
+          });
+          autoCount++;
+        }
+        const autoTargetIds = new Set(pendingRelations.map((r) => r.toEntryId));
+        for (const c of candidates) {
+          if (linksSuggested.length >= MAX_SUGGESTIONS) break;
+          if (autoTargetIds.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 });
+        }
+      }
+      if (links && links.length > 0 && finalEntryId) {
+        for (const link of links) {
+          pendingRelations.push({
+            fromEntryId: finalEntryId,
+            toEntryId: link.to,
+            type: link.type,
+            meta: { source: "user", targetName: link.to, targetCollection: "unknown" }
+          });
+        }
+      }
+      const resolvedCK = canonicalKey;
+      const batchRelationsPromise = pendingRelations.length > 0 ? mcpMutation(
+        "chain.createEntryRelations",
+        {
+          relations: pendingRelations.slice(0, 25).map((r) => ({ fromEntryId: r.fromEntryId, toEntryId: r.toEntryId, type: r.type })),
+          sessionId: agentId ?? void 0
+        }
+      ).catch((err) => {
+        entryWarnings.push(`Auto-linking partially failed: ${err instanceof Error ? err.message : "unknown error"}`);
+        return null;
+      }) : Promise.resolve(null);
+      const cardinalityPromise = resolvedCK ? mcpQuery("chain.checkCardinalityWarning", { canonicalKey: resolvedCK }).catch(() => null) : Promise.resolve(null);
+      const contradictionPromise = runContradictionCheck(name, description);
+      const coachingPromise = mcpMutation("quality.evaluateHeuristicAndSchedule", {
+        entryId: finalEntryId,
+        context: "capture"
+      }).catch(() => null);
+      const [batchResult, cardinalityCheck, contradictionWarnings, verdictResult] = await Promise.all([
+        batchRelationsPromise,
+        cardinalityPromise,
+        contradictionPromise,
+        coachingPromise
+      ]);
+      if (batchResult) {
+        for (let i = 0; i < pendingRelations.length; i++) {
+          const pending = pendingRelations[i];
+          const result = batchResult.results[i];
+          if (!result) continue;
+          if (pending.meta.source === "auto") {
+            if (result.ok) {
+              linksCreated.push({
+                targetEntryId: pending.toEntryId,
+                targetName: pending.meta.targetName,
+                targetCollection: pending.meta.targetCollection,
+                relationType: pending.type,
+                linkReason: pending.meta.linkReason
+              });
+            }
+          } else {
+            if (result.ok) {
+              userLinkResults.push({ label: `\u2713 ${pending.type} \u2192 ${pending.toEntryId}`, ok: true });
+              linksCreated.push({
+                targetEntryId: pending.toEntryId,
+                targetName: pending.meta.targetName,
+                targetCollection: pending.meta.targetCollection,
+                relationType: pending.type
+              });
+            } else {
+              userLinkResults.push({ label: `\u2717 ${pending.type} \u2192 ${pending.toEntryId}: ${result.error ?? "failed"}`, ok: false });
+            }
+          }
+        }
+      }
+      const captureCtx = {
+        collection: resolvedCollection,
+        name,
+        description,
+        context,
+        data,
+        entryId: finalEntryId,
+        canonicalKey,
+        linksCreated,
+        linksSuggested,
+        collectionFields: col.fields ?? []
+      };
+      const quality = scoreQuality(captureCtx, profile);
+      const cardinalityWarning = cardinalityCheck?.warning ?? null;
+      if (contradictionWarnings.length > 0) {
+        await recordSessionActivity({ contradictionWarning: true });
+      }
+      let coachingSection = "";
+      if (verdictResult?.verdict && verdictResult.verdict.tier !== "passive" && verdictResult.verdict.criteria.length > 0) {
+        coachingSection = formatRubricCoaching(verdictResult);
+      }
+      if (verdictResult?.verdict) {
+        try {
+          const wsForTracking = await getWorkspaceContext();
+          const v = verdictResult.verdict;
+          const failedCount = (v.criteria ?? []).filter((c) => !c.passed).length;
+          trackQualityVerdict(wsForTracking.workspaceId, {
+            entry_id: finalEntryId,
+            entry_type: v.canonicalKey ?? resolvedCollection,
+            tier: v.tier,
+            context: "capture",
+            passed: v.passed,
+            source: verdictResult.source ?? "heuristic",
+            criteria_total: v.criteria?.length ?? 0,
+            criteria_failed: failedCount,
+            llm_scheduled: v.tier !== "passive"
+          });
+        } catch {
+        }
+      }
+      const shouldAutoCommit = shouldAutoCommitCapture(autoCommit, wsCtx.governanceMode);
+      let finalStatus = "draft";
+      let commitError = null;
+      if (shouldAutoCommit && finalEntryId) {
+        try {
+          const commitResult = await mcpMutation("chain.commitEntry", {
+            entryId: finalEntryId,
+            author: agentId ? `agent:${agentId}` : void 0,
+            sessionId: agentId ?? void 0
+          });
+          finalStatus = commitResult?.status === "proposal_created" ? "proposed" : "committed";
+          if (finalStatus === "committed") {
+            await recordSessionActivity({ entryModified: internalId });
+          }
+        } catch (e) {
+          commitError = e instanceof Error ? e.message : "unknown error";
+        }
+      }
+      const lines = [
+        `# Captured: ${finalEntryId || name}`,
+        `**${name}** added to \`${resolvedCollection}\` as \`${finalStatus}\``,
+        `**Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})`
+      ];
+      if (classifierMeta) {
+        lines.push("");
+        lines.push("## Classification");
+        if (classifierMeta.abstained) {
+          lines.push(`No classifier coverage for \`${resolvedCollection}\` \u2014 entry accepted as-is.`);
+        } else if (classifierMeta.autoRouted) {
+          lines.push(`Auto-routed to \`${resolvedCollection}\` (${classifierMeta.topConfidence}% confidence).`);
+          if (classifierMeta.reasons.length > 0) {
+            lines.push(`Reason: ${classifierMeta.reasons.join("; ")}.`);
+          }
+          lines.push(`Override: rerun with explicit \`collection\` if wrong.`);
+        } else if (classifierMeta.agrees) {
+          lines.push(`Classifier confirms \`${resolvedCollection}\` (${classifierMeta.topConfidence}% confidence).`);
+        } else {
+          const suggested = classifierMeta.candidates[0]?.collection ?? "unknown";
+          lines.push(`Classifier suggests \`${suggested}\` (${classifierMeta.topConfidence}% confidence) \u2014 review classification.`);
+          if (classifierMeta.reasons.length > 0) {
+            lines.push(`Reason: ${classifierMeta.reasons.join("; ")}.`);
+          }
+          if (classifierMeta.overrideCommand) {
+            lines.push(`Override: \`${classifierMeta.overrideCommand}\``);
+          }
+        }
+      }
+      const appUrl = process.env.PRODUCTBRAIN_APP_URL ?? "https://productbrain.io";
+      const studioUrl = resolvedCollection === "chains" ? `${appUrl.replace(/\/$/, "")}/w/${wsCtx.workspaceSlug}/studio/${internalId}` : void 0;
+      if (studioUrl) {
+        lines.push("");
+        lines.push(`**View in Studio:** ${studioUrl}`);
+      }
+      if (linksCreated.length > 0) {
+        lines.push("");
+        lines.push(`## Auto-linked (${linksCreated.length})`);
+        for (const link of linksCreated) {
+          const reason = link.linkReason ? ` \u2014 because ${link.linkReason}` : "";
+          lines.push(`- -> **${link.relationType}** ${link.targetEntryId}: ${link.targetName} [${link.targetCollection}]${reason}`);
+        }
+      }
+      if (userLinkResults.length > 0) {
+        lines.push("");
+        lines.push("## Requested links");
+        for (const r of userLinkResults) lines.push(`- ${r.label}`);
+      }
+      if (finalStatus === "committed") {
+        const wasAutoCommitted = autoCommit === void 0 && wsCtx.governanceMode === "open";
+        lines.push("");
+        lines.push(`## Committed: ${finalEntryId}`);
+        if (wasAutoCommitted) {
+          lines.push(`**${name}** added to your knowledge base.`);
+        } else {
+          lines.push(`**${name}** promoted to SSOT on the Chain.`);
+        }
+        if (GOVERNED_COLLECTIONS.has(resolvedCollection)) {
+          lines.push(`_Note: \`${resolvedCollection}\` is a governed collection \u2014 ensure this entry has been reviewed._`);
+        }
+      } else if (finalStatus === "proposed") {
+        lines.push("");
+        lines.push(`## Proposal created: ${finalEntryId}`);
+        lines.push(`**${name}** requires consent before it can be committed, so a proposal was created instead of publishing directly.`);
+      } else if (commitError) {
+        lines.push("");
+        lines.push("## Commit failed");
+        lines.push(`Error: ${commitError}. Entry saved as draft \u2014 use \`commit-entry entryId="${finalEntryId}"\` to promote when ready.`);
+      }
+      if (linksSuggested.length > 0) {
+        lines.push("");
+        lines.push("## Suggested links (review and use `relations action=create`)");
+        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._`);
+      }
+      const isBetOrGoal = isBetCapture || resolvedCK === "bet" || resolvedCK === "goal";
+      const hasStrategyLink = linksCreated.some((l) => l.targetCollection === "strategy");
+      if (isBetOrGoal && !hasStrategyLink) {
+        lines.push("");
+        lines.push(
+          `**Strategy link:** This ${isBetCapture ? "bet" : "goal"} doesn't connect to any strategy entry. Consider linking before commit. Use \`graph action=suggest entryId="${finalEntryId}"\` to find strategy entries to connect to.`
+        );
+        await recordSessionActivity({ strategyLinkWarnedForEntryId: internalId });
+      }
+      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 `context action=gather` on these entries before committing.");
+      }
+      if (entryWarnings.length > 0) {
+        lines.push("");
+        lines.push("## Validation Warnings");
+        for (const w of entryWarnings) {
+          lines.push(`- ${w}`);
+        }
+      }
+      if (coachingSection) {
+        lines.push("");
+        lines.push(coachingSection);
+      }
+      lines.push("");
+      lines.push("## Next Steps");
+      const eid = finalEntryId || "(check entry ID)";
+      if (finalStatus === "committed") {
+        lines.push(`1. **Connect it:** \`graph action=suggest entryId="${eid}"\` \u2014 discover additional links`);
+        if (failedChecks.length > 0) {
+          lines.push(`2. **Improve quality:** \`update-entry entryId="${eid}"\` \u2014 fill missing fields`);
+        }
+      } else if (finalStatus === "proposed") {
+        lines.push(`1. **Connect it:** \`graph action=suggest entryId="${eid}"\` \u2014 discover additional links to support the proposal`);
+        if (failedChecks.length > 0) {
+          lines.push(`2. **Improve quality:** \`update-entry entryId="${eid}"\` \u2014 strengthen the entry before approval`);
+        }
+      } else {
+        if (userLinkResults.length === 0) {
+          lines.push(`1. **Connect it:** \`graph action=suggest entryId="${eid}"\` \u2014 discover what this should link to`);
+        }
+        lines.push(`${userLinkResults.length === 0 ? "2" : "1"}. **Commit it:** \`commit-entry entryId="${eid}"\` \u2014 promote from draft to SSOT on the Chain`);
+        if (failedChecks.length > 0) {
+          lines.push(`${userLinkResults.length === 0 ? "3" : "2"}. **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 {
+      }
+      const next = [];
+      if (finalStatus === "committed") {
+        next.push({ tool: "graph", description: "Discover connections", parameters: { action: "suggest", entryId: finalEntryId } });
+      } else if (finalStatus === "proposed") {
+        next.push({ tool: "graph", description: "Discover connections", parameters: { action: "suggest", entryId: finalEntryId } });
+      } else {
+        if (userLinkResults.length === 0) {
+          next.push({ tool: "graph", description: "Discover links", parameters: { action: "suggest", entryId: finalEntryId } });
+        }
+        next.push({ tool: "commit-entry", description: "Commit to Chain", parameters: { entryId: finalEntryId } });
+      }
+      const summary = finalStatus === "committed" ? `Captured and committed ${finalEntryId} (${name}) to ${resolvedCollection}. Quality ${quality.score}/10.` : finalStatus === "proposed" ? `Captured ${finalEntryId} (${name}) in ${resolvedCollection} and created a proposal for commit. Quality ${quality.score}/10.` : `Captured ${finalEntryId} (${name}) as draft in ${resolvedCollection}. Quality ${quality.score}/10.`;
+      const expectedFields = (col.fields ?? []).map((f) => ({
+        key: f.key,
+        type: f.type,
+        ...f.required && { required: true }
+      }));
+      const toolResult = {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: success(
+          summary,
+          {
+            entryId: finalEntryId,
+            collection: resolvedCollection,
+            name,
+            status: finalStatus,
+            qualityScore: quality.score,
+            qualityVerdict: verdictResult?.verdict ? { ...verdictResult.verdict, source: verdictResult.source ?? "heuristic" } : void 0,
+            ...classifierMeta && { classifier: classifierMeta },
+            ...studioUrl && { studioUrl },
+            ...entryWarnings.length > 0 && { warnings: entryWarnings },
+            ...normalizationMeta && (Object.keys(normalizationMeta.remapped).length > 0 || normalizationMeta.rejected.length > 0) && {
+              normalization: {
+                remapped: normalizationMeta.remapped,
+                rejected: normalizationMeta.rejected
+              }
+            },
+            expectedFields
+          },
+          next
+        )
+      };
+      return toolResult;
+    })
+  );
+  trackWriteTool(captureTool);
+  const batchCaptureTool = 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\nCollection is optional per entry \u2014 omit it and the LLM classifier auto-routes (FEAT-160). High/medium confidence entries are created; low confidence entries are skipped and returned with suggested collections for manual review.\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 action=check` on individual entries afterward if needed.\n\nPass `autoCommit: false` to keep the whole batch draft-first. If omitted, Open mode workspaces commit by default and consensus/role modes keep drafts.",
+      inputSchema: batchCaptureSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    withEnvelope(async ({ entries, autoCommit }) => {
+      requireWriteAccess();
+      const agentId = getAgentSessionId();
+      const createdBy = agentId ? `agent:${agentId}` : "capture";
+      const wsCtx = await getWorkspaceContext();
+      const autoCommitApplied = shouldAutoCommitCapture(autoCommit, wsCtx.governanceMode);
+      const needsClassification = entries.map((e, i) => ({ ...e, index: i })).filter((e) => !e.collection);
+      let classificationMap = /* @__PURE__ */ new Map();
+      if (needsClassification.length > 0) {
+        await server.sendLoggingMessage({
+          level: "info",
+          data: `Classifying ${needsClassification.length}/${entries.length} entries via LLM...`,
+          logger: "product-brain"
+        });
+        const classifications = await Promise.all(
+          needsClassification.map(
+            (e) => resolveCollection({ name: e.name, description: e.description }).catch(() => null)
+          )
+        );
+        for (let i = 0; i < needsClassification.length; i++) {
+          classificationMap.set(needsClassification[i].index, classifications[i]);
+        }
+      }
+      const results = [];
+      const skippedLowConfidence = [];
+      await server.sendLoggingMessage({
+        level: "info",
+        data: `Batch capturing ${entries.length} entries...`,
+        logger: "product-brain"
+      });
+      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 (let entryIdx = 0; entryIdx < entries.length; entryIdx++) {
+        const entry = entries[entryIdx];
+        if (entryIdx > 0 && entryIdx % 5 === 0) {
+          await server.sendLoggingMessage({
+            level: "info",
+            data: `Captured ${entryIdx}/${entries.length} entries...`,
+            logger: "product-brain"
+          });
+        }
+        let resolvedSlug = entry.collection;
+        let classifiedBy;
+        let confidence;
+        let confidenceTier;
+        if (resolvedSlug) {
+          classifiedBy = "explicit";
+        } else {
+          const resolved = classificationMap.get(entryIdx);
+          if (!resolved || resolved.tier === "low") {
+            skippedLowConfidence.push({
+              index: entryIdx,
+              name: entry.name,
+              suggestedCollection: resolved?.collection,
+              confidence: resolved?.confidence,
+              alternatives: resolved?.alternatives.slice(0, 3)
+            });
+            continue;
+          }
+          resolvedSlug = resolved.collection;
+          classifiedBy = resolved.classifiedBy;
+          confidence = resolved.confidence;
+          confidenceTier = resolved.tier;
+        }
+        const profile = PROFILES.get(resolvedSlug) ?? FALLBACK_PROFILE;
+        const col = collCache.get(resolvedSlug);
+        if (!col) {
+          results.push({
+            name: entry.name,
+            collection: resolvedSlug,
+            entryId: "",
+            ok: false,
+            autoLinks: 0,
+            status: "draft",
+            classifiedBy,
+            confidence,
+            confidenceTier,
+            error: `Collection "${resolvedSlug}" not found`
+          });
+          continue;
+        }
+        if (entry.entryId && resolvedSlug !== "business-rules" && resolvedSlug !== "standards") {
+          results.push({
+            name: entry.name,
+            collection: resolvedSlug,
+            entryId: "",
+            ok: false,
+            autoLinks: 0,
+            status: "draft",
+            classifiedBy,
+            confidence,
+            confidenceTier,
+            error: `BR-111: entryId only allowed for business-rules and standards. Omit for ${resolvedSlug}.`
+          });
+          continue;
+        }
+        const data = buildDataFromFields(col.fields ?? [], profile.descriptionField, entry.description);
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        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: resolvedSlug,
+            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 result = await mcpMutation("chain.createEntry", {
+            collectionSlug: resolvedSlug,
+            entryId: entry.entryId ?? void 0,
+            name: entry.name,
+            status: "draft",
+            data,
+            createdBy,
+            sessionId: agentId ?? void 0
+          });
+          const internalId = result.docId;
+          const finalEntryId = result.entryId;
+          const batchEntryWarnings = result.warnings ?? [];
+          resolveGapsForEntry(entry.name, result.entryId);
+          let finalStatus = "draft";
+          let commitError;
+          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) => {
+                const conf = computeLinkConfidence(r, entry.name, entry.description, resolvedSlug, collIdToSlug.get(r.collectionId) ?? "unknown");
+                return { ...r, collSlug: collIdToSlug.get(r.collectionId) ?? "unknown", confidence: conf.score };
+              }).sort((a, b) => b.confidence - a.confidence);
+              const batchAutoLinks = [];
+              for (const c of candidates) {
+                if (batchAutoLinks.length >= MAX_AUTO_LINKS) break;
+                if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
+                if (!c.entryId) continue;
+                const { type: relationType } = inferRelationType(resolvedSlug, c.collSlug, profile);
+                batchAutoLinks.push({ fromEntryId: finalEntryId, toEntryId: c.entryId, type: relationType });
+              }
+              if (batchAutoLinks.length > 0) {
+                const batchRes = await mcpMutation("chain.createEntryRelations", {
+                  relations: batchAutoLinks,
+                  sessionId: agentId ?? void 0
+                });
+                autoLinkCount = batchRes.created;
+              }
+            } catch {
+            }
+          }
+          if (autoCommitApplied) {
+            try {
+              const commitResult = await mcpMutation("chain.commitEntry", {
+                entryId: finalEntryId,
+                author: agentId ? `agent:${agentId}` : void 0,
+                sessionId: agentId ?? void 0
+              });
+              finalStatus = commitResult?.status === "proposal_created" ? "proposed" : "committed";
+              if (finalStatus === "committed") {
+                await recordSessionActivity({ entryModified: internalId });
+              }
+            } catch (error) {
+              commitError = error instanceof Error ? error.message : String(error);
+            }
+          }
+          const entryNorm = result.normalization;
+          results.push({
+            name: entry.name,
+            collection: resolvedSlug,
+            entryId: finalEntryId,
+            ok: true,
+            autoLinks: autoLinkCount,
+            status: finalStatus,
+            classifiedBy,
+            confidence,
+            confidenceTier,
+            ...commitError ? { commitError } : {},
+            ...batchEntryWarnings.length > 0 ? { warnings: batchEntryWarnings } : {},
+            ...entryNorm && (Object.keys(entryNorm.remapped).length > 0 || entryNorm.rejected.length > 0) && {
+              normalization: { remapped: entryNorm.remapped, rejected: entryNorm.rejected }
+            }
+          });
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          results.push({
+            name: entry.name,
+            collection: resolvedSlug,
+            entryId: "",
+            ok: false,
+            autoLinks: 0,
+            status: "draft",
+            classifiedBy,
+            confidence,
+            confidenceTier,
+            error: msg
+          });
+        }
+      }
+      const created = results.filter((r) => r.ok);
+      const failed = results.filter((r) => !r.ok);
+      const committed = created.filter((r) => r.status === "committed");
+      const proposed = created.filter((r) => r.status === "proposed");
+      const drafts = created.filter((r) => r.status === "draft");
+      const commitFailures = created.filter((r) => r.commitError);
+      const classifiedCount = created.filter((r) => r.classifiedBy && r.classifiedBy !== "explicit").length;
+      await server.sendLoggingMessage({
+        level: "info",
+        data: `Batch complete. ${created.length} succeeded, ${failed.length} failed, ${skippedLowConfidence.length} skipped (low confidence).`,
+        logger: "product-brain"
+      });
+      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, **${skippedLowConfidence.length}** skipped out of ${entries.length} total.`,
+        `**Auto-links created:** ${totalAutoLinks}`,
+        ""
+      ];
+      if (classifiedCount > 0) {
+        lines.push(`**Auto-classified:** ${classifiedCount} entries routed by LLM/heuristic.`);
+        lines.push("");
+      }
+      if (created.length > 0) {
+        lines.push(
+          `**Statuses:** ${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft.`
+        );
+        lines.push("");
+      }
+      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) {
+        const highConfidence = created.filter((r) => r.confidenceTier === "high" || r.classifiedBy === "explicit");
+        const mediumConfidence = created.filter((r) => r.confidenceTier === "medium");
+        if (highConfidence.length > 0) {
+          lines.push("## Created \u2014 High Confidence / Explicit");
+          for (const r of highConfidence) {
+            const linkNote = r.autoLinks > 0 ? `, ${r.autoLinks} auto-links` : "";
+            const classNote = r.classifiedBy !== "explicit" ? ` (${r.classifiedBy} ${r.confidence}%)` : "";
+            lines.push(`- **${r.entryId}**: ${r.name} [${r.collection}] \u2014 \`${r.status}\`${classNote}${linkNote}`);
+          }
+        }
+        if (mediumConfidence.length > 0) {
+          lines.push("");
+          lines.push("## Created \u2014 Medium Confidence (review recommended)");
+          for (const r of mediumConfidence) {
+            const linkNote = r.autoLinks > 0 ? `, ${r.autoLinks} auto-links` : "";
+            lines.push(`- **${r.entryId}**: ${r.name} [${r.collection}] \u2014 \`${r.status}\` (${r.classifiedBy} ${r.confidence}%)${linkNote}`);
+          }
+          lines.push(`
+_Use \`entries action=move\` to correct any misclassified entries._`);
+        }
+      }
+      if (skippedLowConfidence.length > 0) {
+        lines.push("");
+        lines.push("## Skipped \u2014 Low Confidence (needs explicit collection)");
+        for (const s of skippedLowConfidence) {
+          const suggestion = s.suggestedCollection ? ` \u2014 best guess: \`${s.suggestedCollection}\` (${s.confidence}%)` : " \u2014 no classification available";
+          const alts = s.alternatives?.length ? ` | alternatives: ${s.alternatives.map((a) => `\`${a.collection}\` (${a.confidence}%)`).join(", ")}` : "";
+          lines.push(`- **[${s.index}]** ${s.name}${suggestion}${alts}`);
+        }
+        lines.push("");
+        lines.push("_Re-capture these with an explicit `collection` or use the suggested collection._");
+      }
+      if (commitFailures.length > 0) {
+        lines.push("");
+        lines.push("## Saved as draft");
+        for (const r of commitFailures) {
+          lines.push(`- **${r.entryId}**: ${r.name} [${r.collection}] \u2014 ${r.commitError}`);
+        }
+      }
+      const entriesWithWarnings = created.filter((r) => r.warnings && r.warnings.length > 0);
+      if (entriesWithWarnings.length > 0) {
+        lines.push("");
+        lines.push("## Validation Warnings");
+        for (const r of entriesWithWarnings) {
+          lines.push(`- **${r.entryId}** (${r.name}): ${r.warnings.join("; ")}`);
+        }
+      }
+      if (failed.length > 0) {
+        lines.push("");
+        lines.push("## Failed");
+        for (const r of failed) {
+          lines.push(`- ${r.name} [${r.collection}]: _${r.error}_`);
+        }
+        lines.push("");
+        lines.push(`_If failed > 0, inspect \`failedEntries\` in the structured response and retry individually._`);
+      }
+      const entryIds = created.map((r) => r.entryId);
+      if (entryIds.length > 0 || skippedLowConfidence.length > 0) {
+        lines.push("");
+        lines.push("## Next Steps");
+        if (entryIds.length > 0) {
+          lines.push(`- **Connect:** Run \`graph action=suggest\` on key entries to build the knowledge graph`);
+        }
+        if (drafts.length > 0) {
+          lines.push(`- **Commit:** Use \`commit-entry\` to promote remaining drafts to SSOT`);
+        }
+        if (skippedLowConfidence.length > 0) {
+          lines.push(`- **Classify:** Re-capture ${skippedLowConfidence.length} skipped entries with explicit collections`);
+        }
+        if (entryIds.length > 0) {
+          lines.push(`- **Quality:** Run \`quality action=check\` on individual entries to assess completeness`);
+        }
+      }
+      const skippedNote = skippedLowConfidence.length > 0 ? `, ${skippedLowConfidence.length} skipped (low confidence)` : "";
+      const classifiedNote = classifiedCount > 0 ? `, ${classifiedCount} auto-classified` : "";
+      const summary = failed.length > 0 || skippedLowConfidence.length > 0 ? `Batch captured ${created.length}/${entries.length} entries (${failed.length} failed${skippedNote}, ${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft${classifiedNote}).` : `Batch captured ${created.length} entries successfully (${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft${classifiedNote}).`;
+      const firstDraft = drafts[0];
+      const next = [];
+      if (created.length > 0) {
+        next.push({ tool: "graph", description: "Discover connections", parameters: { action: "suggest", entryId: created[0].entryId } });
+      }
+      if (firstDraft) {
+        next.push({ tool: "commit-entry", description: "Commit first draft", parameters: { entryId: firstDraft.entryId } });
+      }
+      if (skippedLowConfidence.length > 0) {
+        next.push({ tool: "capture", description: `Capture skipped entry with explicit collection`, parameters: { name: skippedLowConfidence[0].name, collection: skippedLowConfidence[0].suggestedCollection ?? "" } });
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: success(
+          summary,
+          {
+            captured: created.map((r) => ({
+              entryId: r.entryId,
+              collection: r.collection,
+              name: r.name,
+              status: r.status,
+              ...r.classifiedBy ? { classifiedBy: r.classifiedBy } : {},
+              ...r.confidence != null ? { confidence: r.confidence } : {},
+              ...r.confidenceTier ? { confidenceTier: r.confidenceTier } : {},
+              ...r.warnings?.length ? { warnings: r.warnings } : {},
+              ...r.normalization ? { normalization: r.normalization } : {}
+            })),
+            total: created.length,
+            failed: failed.length,
+            committed: committed.length,
+            proposed: proposed.length,
+            drafts: drafts.length,
+            ...classifiedCount > 0 ? { classified: classifiedCount } : {},
+            autoCommitApplied,
+            ...skippedLowConfidence.length > 0 && {
+              skippedLowConfidence: skippedLowConfidence.map((s) => ({
+                index: s.index,
+                name: s.name,
+                ...s.suggestedCollection ? { suggestedCollection: s.suggestedCollection } : {},
+                ...s.confidence != null ? { confidence: s.confidence } : {},
+                ...s.alternatives?.length ? { alternatives: s.alternatives } : {}
+              }))
+            },
+            ...failed.length > 0 && {
+              failedEntries: failed.map((r) => ({
+                index: results.indexOf(r),
+                collection: r.collection,
+                name: r.name,
+                error: r.error ?? "unknown error"
+              }))
+            }
+          },
+          next
+        )
+      };
+    })
+  );
+  trackWriteTool(batchCaptureTool);
+}
+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"
+]);
+function tokenizeText(input) {
+  return input.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").split(/\s+/).filter(Boolean);
+}
+async function runContradictionCheck(name, description) {
+  const warnings = [];
+  try {
+    const keyTerms = tokenizeText(`${name} ${description}`).filter((w) => w.length >= 4 && !STOP_WORDS.has(w)).slice(0, 8);
+    if (keyTerms.length === 0) return warnings;
+    const searchQuery = keyTerms.slice(0, 5).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 entryTokens = new Set(tokenizeText(`${entry.name} ${entry.data?.description ?? ""}`));
+      const matched = keyTerms.filter((t) => entryTokens.has(t));
+      if (matched.length < 3) 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;
+}
+function formatRubricCoaching(result) {
+  const { verdict, rogerMartin } = result;
+  if (!verdict || verdict.criteria.length === 0) return "";
+  const lines = ["## Semantic Quality"];
+  const failed = (verdict.criteria ?? []).filter((c) => !c.passed);
+  const total = verdict.criteria?.length ?? 0;
+  const passedCount = total - failed.length;
+  if (verdict.passed) {
+    lines.push(`All ${total} rubric criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier).`);
+  } else {
+    lines.push(`${passedCount}/${total} criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier)`);
+    lines.push("");
+    for (const c of verdict.criteria) {
+      const icon = c.passed ? "[x]" : "[ ]";
+      const extra = c.passed ? "" : ` \u2014 ${c.hint}`;
+      lines.push(`${icon} ${c.id}${extra}`);
+    }
+    if (verdict.weakest) {
+      lines.push("");
+      lines.push(`**Coaching hint:** ${verdict.weakest.hint}`);
+      lines.push(`_Question to consider:_ ${verdict.weakest.questionTemplate}`);
+    }
+  }
+  if (rogerMartin) {
+    lines.push("");
+    lines.push("### Roger Martin Test");
+    if (rogerMartin.isStrategicChoice) {
+      lines.push("This principle passes \u2014 the opposite is a reasonable strategic choice.");
+    } else {
+      lines.push(`This principle may not be a strategic choice. ${rogerMartin.reasoning}`);
+      if (rogerMartin.suggestion) {
+        lines.push(`_Suggestion:_ ${rogerMartin.suggestion}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatRubricVerdictSection(verdict) {
+  if (!verdict || !verdict.criteria || verdict.criteria.length === 0) return "";
+  const lines = ["## Semantic Quality"];
+  const failed = verdict.criteria.filter((c) => !c.passed);
+  const total = verdict.criteria.length;
+  const passedCount = total - failed.length;
+  const durationSuffix = verdict.llmDurationMs ? ` in ${(verdict.llmDurationMs / 1e3).toFixed(1)}s` : "";
+  const statusNote = verdict.llmStatus === "pending" ? " \u2014 LLM evaluation in progress..." : verdict.llmStatus === "failed" ? ` \u2014 LLM evaluation failed${verdict.llmError ? `: ${verdict.llmError}` : ""}, showing heuristic results` : verdict.source === "llm" && durationSuffix ? ` \u2014 evaluated${durationSuffix}` : "";
+  if (failed.length === 0) {
+    lines.push(`All ${total} rubric criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier, ${verdict.source} evaluation).${statusNote}`);
+  } else {
+    lines.push(`${passedCount}/${total} criteria pass for \`${verdict.canonicalKey}\` (${verdict.tier} tier, ${verdict.source} evaluation)${statusNote}`);
+    lines.push("");
+    for (const c of verdict.criteria) {
+      const icon = c.passed ? "[x]" : "[ ]";
+      const extra = c.passed ? "" : ` \u2014 ${c.hint}`;
+      lines.push(`${icon} ${c.id}${extra}`);
+    }
+    if (verdict.weakest) {
+      lines.push("");
+      lines.push(`**Top improvement:** ${verdict.weakest.hint}`);
+    }
+  }
+  if (verdict.rogerMartin) {
+    const rm = verdict.rogerMartin;
+    lines.push("");
+    lines.push("### Roger Martin Test");
+    if (rm.isStrategicChoice) {
+      lines.push(`This is a real strategic choice \u2014 the opposite is reasonable. ${rm.reasoning}`);
+    } else {
+      lines.push(`This may not be a strategic choice. ${rm.reasoning}`);
+      if (rm.suggestion) {
+        lines.push(`_Suggestion:_ ${rm.suggestion}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  runWithAuth,
+  runWithToolContext,
+  getAgentSessionId,
+  isSessionOriented,
+  setSessionOriented,
+  getApiKeyScope,
+  startAgentSession,
+  closeAgentSession,
+  orphanAgentSession,
+  recordSessionActivity,
+  bootstrap,
+  bootstrapHttp,
+  getAuditLog,
+  mcpCall,
+  getWorkspaceId,
+  getWorkspaceContext,
+  mcpQuery,
+  mcpMutation,
+  requireActiveSession,
+  requireWriteAccess,
+  recoverSessionState,
+  deriveEpistemicStatus,
+  formatEpistemicLine,
+  toEpistemicInput,
+  extractPreview,
+  translateStaleToolNames,
+  initToolSurface,
+  trackWriteTool,
+  initFeatureFlags,
+  recordGap,
+  getSessionGaps,
+  getTopGaps,
+  clearSessionGaps,
+  CLASSIFIER_AUTO_ROUTE_THRESHOLD,
+  CLASSIFIABLE_COLLECTIONS,
+  classifyCollection,
+  isClassificationAmbiguous,
+  resolveCollection,
+  success,
+  failure,
+  parseOrFail,
+  unknownAction,
+  successResult,
+  failureResult,
+  notFoundResult,
+  validationResult,
+  withEnvelope,
+  STARTER_COLLECTIONS,
+  inferStrategyCategory,
+  formatQualityReport,
+  checkEntryQuality,
+  captureSchema,
+  batchCaptureSchema,
+  captureClassifierSchema,
+  captureOutputSchema,
+  batchCaptureOutputSchema,
+  registerSmartCaptureTools,
+  runContradictionCheck,
+  formatRubricCoaching,
+  formatRubricVerdictSection
+};
+//# sourceMappingURL=chunk-G4JJNINW.js.map