@productbrain/mcp 0.0.1-beta.39 → 0.0.1-beta.40

package/dist/{chunk-7VJP2IMS.js → chunk-M264FY2V.js}

@@ -1,7 +1,10 @@
 import {
+  trackCaptureClassifierAutoRouted,
+  trackCaptureClassifierEvaluated,
+  trackCaptureClassifierFallback,
   trackQualityVerdict,
   trackToolCall
-} from "./chunk-TB24VJ4Z.js";
+} from "./chunk-P7ABQEFK.js";
 
 // src/tools/smart-capture.ts
 import { z } from "zod";
@@ -27,6 +30,7 @@ function newKeyState() {
     workspaceSlug: null,
     workspaceName: null,
     workspaceCreatedAt: null,
+    workspaceGovernanceMode: null,
     agentSessionId: null,
     apiKeyId: null,
     apiKeyScope: "readwrite",
@@ -112,6 +116,7 @@ var _stdioState = {
   workspaceSlug: null,
   workspaceName: null,
   workspaceCreatedAt: null,
+  workspaceGovernanceMode: null,
   agentSessionId: null,
   apiKeyId: null,
   apiKeyScope: "readwrite",
@@ -328,6 +333,7 @@ async function resolveWorkspaceWithRetry(maxRetries = 2) {
       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;
@@ -352,7 +358,8 @@ async function getWorkspaceContext() {
     workspaceId,
     workspaceSlug: s.workspaceSlug ?? "unknown",
     workspaceName: s.workspaceName ?? "unknown",
-    createdAt: s.workspaceCreatedAt
+    createdAt: s.workspaceCreatedAt,
+    governanceMode: s.workspaceGovernanceMode ?? "open"
   };
 }
 async function mcpQuery(fn, args = {}) {
@@ -475,6 +482,189 @@ 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/tools/smart-capture-routing.ts
+var CLASSIFIER_AUTO_ROUTE_THRESHOLD = 70;
+var CLASSIFIER_AMBIGUITY_MARGIN = 15;
+var STARTER_COLLECTIONS = ["decisions", "tensions", "glossary", "insights", "bets"];
+var SIGNAL_WEIGHT = 10;
+var MAX_MATCHES_PER_SIGNAL = 2;
+var MAX_REASON_COUNT = 3;
+var STARTER_COLLECTION_SIGNALS = {
+  decisions: [
+    "decide",
+    "decision",
+    "chose",
+    "chosen",
+    "choice",
+    "resolved",
+    "we will",
+    "we should",
+    "approved"
+  ],
+  tensions: [
+    "problem",
+    "issue",
+    "blocked",
+    "blocker",
+    "friction",
+    "pain",
+    "risk",
+    "constraint",
+    "bottleneck",
+    "struggle"
+  ],
+  glossary: [
+    "definition",
+    "define",
+    "term",
+    "means",
+    "refers to",
+    "is called",
+    "vocabulary",
+    "terminology"
+  ],
+  insights: [
+    "insight",
+    "learned",
+    "observed",
+    "pattern",
+    "trend",
+    "signal",
+    "found that",
+    "evidence"
+  ],
+  bets: [
+    "bet",
+    "appetite",
+    "scope",
+    "elements",
+    "rabbit hole",
+    "no-go",
+    "shape",
+    "shaping",
+    "done when"
+  ]
+};
+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 classifyStarterCollection(name, description) {
+  const text = `${name} ${description}`.toLowerCase();
+  const rawScores = [];
+  for (const collection of STARTER_COLLECTIONS) {
+    const signals = STARTER_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((a, b) => b.score - a.score);
+  const top = rawScores[0];
+  const second = rawScores[1];
+  if (!top || top.score <= 0) return null;
+  const margin = Math.max(0, top.score - (second?.score ?? 0));
+  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 shouldAutoRouteClassification(result) {
+  if (result.confidence < CLASSIFIER_AUTO_ROUTE_THRESHOLD) return false;
+  if (result.scoreMargin < CLASSIFIER_AMBIGUITY_MARGIN) return false;
+  return true;
+}
+function isClassificationAmbiguous(result) {
+  return result.scoreMargin < CLASSIFIER_AMBIGUITY_MARGIN;
+}
+
 // src/tools/smart-capture.ts
 var AREA_KEYWORDS = {
   "Architecture": ["convex", "schema", "database", "migration", "api", "backend", "infrastructure", "scaling", "performance"],
@@ -1020,8 +1210,9 @@ var GOVERNED_COLLECTIONS = /* @__PURE__ */ new Set([
 var AUTO_LINK_CONFIDENCE_THRESHOLD = 35;
 var MAX_AUTO_LINKS = 5;
 var MAX_SUGGESTIONS = 5;
+var CAPTURE_WITHOUT_THINKING_FLAG = "capture-without-thinking";
 var captureSchema = z.object({
-  collection: z.string().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'"),
+  collection: z.string().optional().describe("Collection slug, e.g. 'tensions', 'business-rules', 'glossary', 'decisions'. Optional when `capture-without-thinking` is enabled."),
   name: z.string().describe("Display name \u2014 be specific (e.g. 'Convex adjacency list won't scale for graph traversal')"),
   description: z.string().describe("Full context \u2014 what's happening, why it matters, what you observed"),
   context: z.string().optional().describe("Optional additional context (e.g. 'Observed during context gather calls taking 700ms+')"),
@@ -1042,14 +1233,223 @@ var batchCaptureSchema = z.object({
     entryId: z.string().optional().describe("Optional custom entry ID")
   })).min(1).max(50).describe("Array of entries to capture")
 });
-var captureOutputSchema = z.object({
+var captureClassifierSchema = z.object({
+  enabled: z.boolean(),
+  autoRouted: z.boolean(),
+  topConfidence: z.number(),
+  // Backward-compatible alias for topConfidence.
+  confidence: z.number(),
+  reasons: z.array(z.string()),
+  candidates: z.array(
+    z.object({
+      collection: z.enum(STARTER_COLLECTIONS),
+      signalScore: z.number(),
+      // Backward-compatible alias for signalScore.
+      confidence: z.number()
+    })
+  )
+});
+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."
+    }]
+  };
+}
+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: {
+      classifier: {
+        enabled: true,
+        autoRouted: false,
+        topConfidence: 0,
+        confidence: 0,
+        reasons: [],
+        candidates: []
+      }
+    }
+  };
+}
+function buildProvisionedCollectionSuggestions(candidates) {
+  return candidates.length ? candidates.map((c) => `- \`${c.collection}\` (${c.signalScore}% signal score)`).join("\n") : "- No provisioned starter collection candidates were inferred confidently.";
+}
+function buildUnsupportedProvisioningResult(classified, provisionedCandidates) {
+  const suggestions = buildProvisionedCollectionSuggestions(provisionedCandidates);
+  return {
+    content: [{
+      type: "text",
+      text: `Collection inference is not safe to auto-route yet.
+
+Predicted collection \`${classified.collection}\` is not provisioned/supported for auto-routing in this workspace.
+Reason: ${classified.reasons.join("; ") || "low signal"}
+
+Choose one of these provisioned starter collections and retry with \`collection\`:
+${suggestions}
+
+Correction path: rerun with explicit \`collection\`.`
+    }],
+    structuredContent: {
+      classifier: {
+        enabled: true,
+        autoRouted: false,
+        topConfidence: classified.topConfidence,
+        confidence: classified.confidence,
+        reasons: classified.reasons,
+        candidates: provisionedCandidates
+      }
+    }
+  };
+}
+function buildAmbiguousRouteResult(classified, classifierMeta, ambiguousRoute) {
+  const suggestions = buildProvisionedCollectionSuggestions(classifierMeta.candidates);
+  return {
+    content: [{
+      type: "text",
+      text: "Collection inference is not safe to auto-route yet.\n\n" + (ambiguousRoute ? "Routing held because intent is ambiguous across top candidates.\n\n" : "") + `Predicted: \`${classified.collection}\` (${classified.topConfidence}% top confidence)
+Reason: ${classified.reasons.join("; ") || "low signal"}
+
+Choose one of these and retry with \`collection\`:
+${suggestions}
+
+Correction path: if this was close, rerun with your chosen \`collection\`.`
+    }],
+    structuredContent: {
+      classifier: classifierMeta
+    }
+  };
+}
+async function getProvisionedStarterCollectionCandidates(classified, supportedStarterCollections) {
+  const allCollections = await mcpQuery("chain.listCollections");
+  const provisionedStarterCollections = new Set(
+    (allCollections ?? []).map((collection) => collection.slug).filter(
+      (slug) => supportedStarterCollections.has(slug)
+    )
+  );
+  const provisionedCandidates = classified.candidates.filter(
+    (candidate) => provisionedStarterCollections.has(candidate.collection)
+  );
+  return { provisionedStarterCollections, provisionedCandidates };
+}
+async function resolveCaptureCollection(params) {
+  const {
+    collection,
+    name,
+    description,
+    classifierFlagOn,
+    supportedStarterCollections,
+    workspaceId,
+    explicitCollectionProvided
+  } = params;
+  if (collection) {
+    return { resolvedCollection: collection };
+  }
+  if (!classifierFlagOn) {
+    return { earlyResult: buildCollectionRequiredResult() };
+  }
+  const classified = classifyStarterCollection(name, description);
+  if (!classified) {
+    trackClassifierTelemetry({
+      workspaceId,
+      predictedCollection: "unknown",
+      confidence: 0,
+      autoRouted: false,
+      reasonCategory: "low-confidence",
+      explicitCollectionProvided,
+      outcome: "fallback"
+    });
+    return { earlyResult: buildClassifierUnknownResult() };
+  }
+  const { provisionedStarterCollections, provisionedCandidates } = await getProvisionedStarterCollectionCandidates(classified, supportedStarterCollections);
+  if (!provisionedStarterCollections.has(classified.collection)) {
+    trackClassifierTelemetry({
+      workspaceId,
+      predictedCollection: classified.collection,
+      confidence: classified.confidence,
+      autoRouted: false,
+      reasonCategory: "non-provisioned",
+      explicitCollectionProvided,
+      outcome: "fallback"
+    });
+    return {
+      earlyResult: buildUnsupportedProvisioningResult(classified, provisionedCandidates)
+    };
+  }
+  const autoRoute = shouldAutoRouteClassification(classified);
+  const ambiguousRoute = isClassificationAmbiguous(classified);
+  const classifierMeta = {
+    enabled: true,
+    autoRouted: autoRoute,
+    topConfidence: classified.topConfidence,
+    confidence: classified.confidence,
+    reasons: classified.reasons,
+    candidates: provisionedCandidates
+  };
+  if (!autoRoute) {
+    trackClassifierTelemetry({
+      workspaceId,
+      predictedCollection: classified.collection,
+      confidence: classified.confidence,
+      autoRouted: false,
+      reasonCategory: ambiguousRoute ? "ambiguous" : "low-confidence",
+      explicitCollectionProvided,
+      outcome: "fallback"
+    });
+    return {
+      classifierMeta,
+      earlyResult: buildAmbiguousRouteResult(classified, classifierMeta, ambiguousRoute)
+    };
+  }
+  trackClassifierTelemetry({
+    workspaceId,
+    predictedCollection: classified.collection,
+    confidence: classified.confidence,
+    autoRouted: true,
+    reasonCategory: "auto-routed",
+    explicitCollectionProvided,
+    outcome: "auto-routed"
+  });
+  return {
+    resolvedCollection: classified.collection,
+    classifierMeta
+  };
+}
+var captureSuccessOutputSchema = z.object({
   entryId: z.string(),
   collection: z.string(),
   name: z.string(),
   status: z.enum(["draft", "committed"]),
-  qualityScore: z.number().optional(),
-  qualityVerdict: z.record(z.unknown()).optional()
-});
+  qualityScore: z.number(),
+  qualityVerdict: z.record(z.unknown()).optional(),
+  classifier: captureClassifierSchema.optional(),
+  studioUrl: z.string().optional()
+}).strict();
+var captureClassifierOnlyOutputSchema = z.object({
+  classifier: captureClassifierSchema
+}).strict();
+var captureOutputSchema = z.union([
+  captureSuccessOutputSchema,
+  captureClassifierOnlyOutputSchema
+]);
 var batchCaptureOutputSchema = z.object({
   captured: z.array(z.object({
     entryId: z.string(),
@@ -1057,31 +1457,64 @@ var batchCaptureOutputSchema = z.object({
     name: z.string()
   })),
   total: z.number(),
-  failed: z.number()
+  failed: z.number(),
+  failedEntries: z.array(z.object({
+    index: z.number(),
+    collection: z.string(),
+    name: z.string(),
+    error: z.string()
+  })).optional()
 });
 function registerSmartCaptureTools(server) {
+  const supportedStarterCollections = new Set(
+    STARTER_COLLECTIONS.filter((slug) => PROFILES.has(slug))
+  );
   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 collection, name, and description \u2014 everything else is inferred or auto-filled.\n\nSupported collections with smart profiles: tensions, business-rules, glossary, decisions, features, audiences, strategy, standards, maps, chains, tracking-events.\nAll other collections get an ENT-{random} ID and sensible defaults.\n\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). Pass `autoCommit: true` to promote the entry from draft to SSOT immediately after linking. Governed collections (glossary, business-rules, principles, standards, strategy, features) will warn but still commit \u2014 use only when you're certain.\n\nAlways creates as 'draft' unless `autoCommit` is true. Use `update-entry` for post-creation adjustments.",
+      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, 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). Pass `autoCommit: true` to promote the entry from draft to SSOT immediately after linking. Governed collections (glossary, business-rules, principles, standards, strategy, features) will warn but still commit \u2014 use only when you're certain.\n\nAlways creates as 'draft' unless `autoCommit` is true. Use `update-entry` for post-creation adjustments.",
       inputSchema: captureSchema.shape,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
     },
     async ({ collection, name, description, context, entryId, canonicalKey, data: userData, links, autoCommit }) => {
       requireWriteAccess();
-      const profile = PROFILES.get(collection) ?? FALLBACK_PROFILE;
-      const col = await mcpQuery("chain.getCollection", { slug: collection });
+      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,
+        supportedStarterCollections,
+        workspaceId: wsCtx.workspaceId,
+        explicitCollectionProvided
+      });
+      if (resolution.earlyResult) {
+        return resolution.earlyResult;
+      }
+      const resolvedCollection = resolution.resolvedCollection;
+      const classifierMeta = resolution.classifierMeta;
+      if (!resolvedCollection) {
+        return buildCollectionRequiredResult();
+      }
+      const profile = PROFILES.get(resolvedCollection) ?? FALLBACK_PROFILE;
+      const col = await mcpQuery("chain.getCollection", { slug: resolvedCollection });
       if (!col) {
-        const displayName = collection.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+        const displayName = resolvedCollection.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
         return {
           content: [{
             type: "text",
-            text: `Collection \`${collection}\` not found.
+            text: `Collection \`${resolvedCollection}\` not found.
 
 **To create it**, run:
 \`\`\`
-collections action=create slug="${collection}" name="${displayName}" description="..."
+collections action=create slug="${resolvedCollection}" name="${displayName}" description="..."
 \`\`\`
 
 Or use \`collections action=list\` to see available collections.`
@@ -1110,7 +1543,7 @@ Or use \`collections action=list\` to see available collections.`
       }
       if (profile.inferField) {
         const inferred = profile.inferField({
-          collection,
+          collection: resolvedCollection,
           name,
           description,
           context,
@@ -1138,7 +1571,7 @@ Or use \`collections action=list\` to see available collections.`
       try {
         const agentId = getAgentSessionId();
         const result = await mcpMutation("chain.createEntry", {
-          collectionSlug: collection,
+          collectionSlug: resolvedCollection,
           entryId: entryId ?? void 0,
           name,
           status,
@@ -1179,7 +1612,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         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, collection, collMap.get(r.collectionId) ?? "unknown");
+          const conf = computeLinkConfidence(r, name, description, resolvedCollection, collMap.get(r.collectionId) ?? "unknown");
           return {
             ...r,
             collSlug: collMap.get(r.collectionId) ?? "unknown",
@@ -1191,7 +1624,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
           if (linksCreated.length >= MAX_AUTO_LINKS) break;
           if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
           if (!c.entryId || !finalEntryId) continue;
-          const { type: relationType, reason: relationReason } = inferRelationType(collection, c.collSlug, profile);
+          const { type: relationType, reason: relationReason } = inferRelationType(resolvedCollection, c.collSlug, profile);
           try {
             await mcpMutation("chain.createEntryRelation", {
               fromEntryId: finalEntryId,
@@ -1246,7 +1679,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         }
       }
       const captureCtx = {
-        collection,
+        collection: resolvedCollection,
         name,
         description,
         context,
@@ -1294,7 +1727,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
           const failedCount = (v.criteria ?? []).filter((c) => !c.passed).length;
           trackQualityVerdict(wsForTracking.workspaceId, {
             entry_id: finalEntryId,
-            entry_type: v.canonicalKey ?? collection,
+            entry_type: v.canonicalKey ?? resolvedCollection,
             tier: v.tier,
             context: "capture",
             passed: v.passed,
@@ -1306,9 +1739,10 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         } catch {
         }
       }
+      const shouldAutoCommit = autoCommit === true || autoCommit === void 0 && wsCtx.governanceMode === "open";
       let finalStatus = "draft";
       let commitError = null;
-      if (autoCommit && finalEntryId) {
+      if (shouldAutoCommit && finalEntryId) {
         try {
           await mcpMutation("chain.commitEntry", { entryId: finalEntryId });
           finalStatus = "committed";
@@ -1317,14 +1751,22 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
           commitError = e instanceof Error ? e.message : "unknown error";
         }
       }
-      const wsCtx = await getWorkspaceContext();
       const lines = [
         `# Captured: ${finalEntryId || name}`,
-        `**${name}** added to \`${collection}\` as \`${finalStatus}\``,
+        `**${name}** added to \`${resolvedCollection}\` as \`${finalStatus}\``,
         `**Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})`
       ];
+      if (classifierMeta?.autoRouted) {
+        lines.push("");
+        lines.push("## Collection routing");
+        lines.push(`Auto-routed to \`${resolvedCollection}\` (${classifierMeta.topConfidence}% top confidence).`);
+        if (classifierMeta.reasons.length > 0) {
+          lines.push(`Reason: ${classifierMeta.reasons.join("; ")}.`);
+        }
+        lines.push("Correction path: rerun capture with explicit `collection` if this routing is wrong.");
+      }
       const appUrl = process.env.PRODUCTBRAIN_APP_URL ?? "https://productbrain.io";
-      const studioUrl = collection === "bets" ? `${appUrl.replace(/\/$/, "")}/w/${wsCtx.workspaceSlug}/studio/${internalId}` : void 0;
+      const studioUrl = resolvedCollection === "bets" ? `${appUrl.replace(/\/$/, "")}/w/${wsCtx.workspaceSlug}/studio/${internalId}` : void 0;
       if (studioUrl) {
         lines.push("");
         lines.push(`**View in Studio:** ${studioUrl}`);
@@ -1343,16 +1785,21 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         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}`);
-        lines.push(`**${name}** promoted to SSOT on the Chain.`);
-        if (GOVERNED_COLLECTIONS.has(collection)) {
-          lines.push(`_Note: \`${collection}\` is a governed collection \u2014 ensure this entry has been reviewed._`);
+        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 (commitError) {
         lines.push("");
         lines.push("## Commit failed");
-        lines.push(`Error: ${commitError}. Entry remains as draft.`);
+        lines.push(`Error: ${commitError}. Entry saved as draft \u2014 use \`commit-entry entryId="${finalEntryId}"\` to promote when ready.`);
       }
       if (linksSuggested.length > 0) {
         lines.push("");
@@ -1370,12 +1817,12 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         lines.push("");
         lines.push(`_To improve: \`update-entry entryId="${finalEntryId}"\` to fill missing fields._`);
       }
-      const isBetOrGoal = collection === "bets" || resolvedCK === "bet" || resolvedCK === "goal";
+      const isBetOrGoal = resolvedCollection === "bets" || resolvedCK === "bet" || resolvedCK === "goal";
       const hasStrategyLink = linksCreated.some((l) => l.targetCollection === "strategy");
       if (isBetOrGoal && !hasStrategyLink) {
         lines.push("");
         lines.push(
-          `**Strategy link:** This ${collection === "bets" ? "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.`
+          `**Strategy link:** This ${resolvedCollection === "bets" ? "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 });
       }
@@ -1428,11 +1875,12 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         content: [{ type: "text", text: lines.join("\n") }],
         structuredContent: {
           entryId: finalEntryId,
-          collection,
+          collection: resolvedCollection,
           name,
           status: finalStatus,
           qualityScore: quality.score,
           qualityVerdict: verdictResult?.verdict ? { ...verdictResult.verdict, source: verdictResult.source ?? "heuristic" } : void 0,
+          ...classifierMeta && { classifier: classifierMeta },
           ...studioUrl && { studioUrl }
         }
       };
@@ -1717,11 +2165,13 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "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 text = `${name} ${description}`.toLowerCase();
-    const keyTerms = text.split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS.has(w)).slice(0, 8);
+    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([
@@ -1730,8 +2180,8 @@ async function runContradictionCheck(name, description) {
     ]);
     const allGov = [...govResults ?? [], ...archResults ?? []].slice(0, 5);
     for (const entry of allGov) {
-      const entryText = `${entry.name} ${entry.data?.description ?? ""}`.toLowerCase();
-      const matched = keyTerms.filter((t) => entryText.includes(t));
+      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 {
@@ -1854,10 +2304,16 @@ export {
   translateStaleToolNames,
   initToolSurface,
   trackWriteTool,
+  initFeatureFlags,
+  CLASSIFIER_AUTO_ROUTE_THRESHOLD,
+  STARTER_COLLECTIONS,
+  classifyStarterCollection,
+  isClassificationAmbiguous,
   formatQualityReport,
   checkEntryQuality,
   captureSchema,
   batchCaptureSchema,
+  captureClassifierSchema,
   captureOutputSchema,
   batchCaptureOutputSchema,
   registerSmartCaptureTools,
@@ -1865,4 +2321,4 @@ export {
   formatRubricCoaching,
   formatRubricVerdictSection
 };
-//# sourceMappingURL=chunk-7VJP2IMS.js.map
+//# sourceMappingURL=chunk-M264FY2V.js.map