@productbrain/mcp 0.0.1-beta.66 → 0.0.1-beta.67

package/dist/{chunk-UWILSX73.js → chunk-TH5AUVVM.js}

@@ -939,17 +939,108 @@ function classifyCollection(name, description) {
     }))
   };
 }
-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-routing.ts
-var STARTER_COLLECTIONS = CLASSIFIABLE_COLLECTIONS;
+// 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";
@@ -1159,6 +1250,9 @@ function withEnvelope(handler) {
   };
 }
 
+// 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"],
@@ -1838,7 +1932,7 @@ var captureSchema = z2.object({
 });
 var batchCaptureSchema = z2.object({
   entries: z2.array(z2.object({
-    collection: z2.string().describe("Collection slug"),
+    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: z2.string().optional().describe("Optional custom entry ID")
@@ -1857,13 +1951,16 @@ var captureClassifierSchema = z2.object({
   reasons: z2.array(z2.string()),
   candidates: z2.array(
     z2.object({
-      collection: z2.enum(CLASSIFIABLE_COLLECTIONS),
-      signalScore: z2.number(),
+      collection: z2.string(),
+      signalScore: z2.number().optional(),
       confidence: z2.number()
     })
   ),
   agentProvidedCollection: z2.string().optional(),
-  overrideCommand: 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 = {
@@ -1909,58 +2006,28 @@ function buildClassifierUnknownResult() {
     )
   };
 }
-function buildProvisionedCollectionSuggestions(candidates) {
-  return candidates.length ? candidates.map((c) => `- \`${c.collection}\` (${c.signalScore}% signal score)`).join("\n") : "- No provisioned collection candidates were inferred confidently.";
-}
-function buildUnsupportedProvisioningResult(classified, provisionedCandidates) {
-  const suggestions = buildProvisionedCollectionSuggestions(provisionedCandidates);
-  const textBody = `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}
+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}).
 
-Correction path: rerun with explicit \`collection\`.`;
-  return {
-    content: [{ type: "text", text: textBody }],
-    structuredContent: failure(
-      "VALIDATION_ERROR",
-      `Collection '${classified.collection}' is not provisioned for auto-routing.`,
-      "Rerun with explicit collection.",
-      [{ tool: "collections", description: "List available collections", parameters: { action: "list" } }],
-      {
-        classifier: {
-          enabled: true,
-          autoRouted: false,
-          agrees: false,
-          abstained: false,
-          topConfidence: classified.topConfidence,
-          confidence: classified.confidence,
-          reasons: classified.reasons,
-          candidates: provisionedCandidates.map((c) => ({ collection: c.collection, signalScore: c.signalScore, confidence: c.confidence }))
-        }
-      }
-    )
-  };
-}
-function buildAmbiguousRouteResult(classified, classifierMeta, ambiguousRoute) {
-  const suggestions = buildProvisionedCollectionSuggestions(classifierMeta.candidates);
-  const textBody = "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"}
+Predicted: \`${resolved.collection}\`
+Reason: ${resolved.reasoning || "low signal"}
 
 Choose one of these and retry with \`collection\`:
 ${suggestions}
 
-Correction path: if this was close, rerun with your chosen \`collection\`.`;
+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",
-      ambiguousRoute ? `Ambiguous routing \u2014 top candidates too close (${classified.topConfidence}% confidence).` : `Low confidence routing to '${classified.collection}' (${classified.topConfidence}%).`,
+      `Low confidence routing to '${resolved.collection}' (${resolved.confidence}%, ${resolved.classifiedBy}).`,
       "Rerun with explicit collection.",
-      classifierMeta.candidates.map((c) => ({
+      allCandidates.map((c) => ({
         tool: "capture",
         description: `Capture to ${c.collection}`,
         parameters: { collection: c.collection }
@@ -1969,17 +2036,24 @@ Correction path: if this was close, rerun with your chosen \`collection\`.`;
     )
   };
 }
-async function getProvisionedCollectionCandidates(classified, supportedCollections) {
-  const allCollections = await mcpQuery("chain.listCollections");
-  const provisionedCollections = new Set(
-    (allCollections ?? []).map((collection) => collection.slug).filter(
-      (slug) => supportedCollections.has(slug)
-    )
-  );
-  const provisionedCandidates = classified.candidates.filter(
-    (candidate) => provisionedCollections.has(candidate.collection)
-  );
-  return { provisionedCollections, provisionedCandidates };
+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 {
@@ -1987,33 +2061,26 @@ async function resolveCaptureCollection(params) {
     name,
     description,
     classifierFlagOn,
-    supportedCollections,
     workspaceId,
     explicitCollectionProvided
   } = params;
   if (collection) {
-    const classified2 = classifyCollection(name, description);
-    if (classified2) {
-      const agrees = classified2.collection === collection;
-      const classifierMeta2 = {
-        enabled: true,
+    const resolved2 = await resolveCollection({ name, description });
+    if (resolved2) {
+      const agrees = resolved2.collection === collection;
+      const classifierMeta2 = buildClassifierMeta(resolved2, {
         autoRouted: false,
         agrees,
-        abstained: false,
-        topConfidence: classified2.topConfidence,
-        confidence: classified2.confidence,
-        reasons: classified2.reasons,
-        candidates: classified2.candidates.slice(0, 3),
         agentProvidedCollection: collection,
         ...!agrees && {
-          overrideCommand: `capture collection="${classified2.collection}"`
+          overrideCommand: `capture collection="${resolved2.collection}"`
         }
-      };
+      });
       if (!agrees) {
         trackClassifierTelemetry({
           workspaceId,
-          predictedCollection: classified2.collection,
-          confidence: classified2.confidence,
+          predictedCollection: resolved2.collection,
+          confidence: resolved2.confidence,
           autoRouted: false,
           reasonCategory: "low-confidence",
           explicitCollectionProvided: true,
@@ -2040,8 +2107,8 @@ async function resolveCaptureCollection(params) {
   if (!classifierFlagOn) {
     return { earlyResult: buildCollectionRequiredResult() };
   }
-  const classified = classifyCollection(name, description);
-  if (!classified) {
+  const resolved = await resolveCollection({ name, description });
+  if (!resolved) {
     trackClassifierTelemetry({
       workspaceId,
       predictedCollection: "unknown",
@@ -2053,59 +2120,34 @@ async function resolveCaptureCollection(params) {
     });
     return { earlyResult: buildClassifierUnknownResult() };
   }
-  const { provisionedCollections, provisionedCandidates } = await getProvisionedCollectionCandidates(classified, supportedCollections);
-  if (!provisionedCollections.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,
-    agrees: true,
-    abstained: false,
-    topConfidence: classified.topConfidence,
-    confidence: classified.confidence,
-    reasons: classified.reasons,
-    candidates: provisionedCandidates
-  };
+  const autoRoute = resolved.tier !== "low";
+  const classifierMeta = buildClassifierMeta(resolved, { autoRouted: autoRoute });
   if (!autoRoute) {
     trackClassifierTelemetry({
       workspaceId,
-      predictedCollection: classified.collection,
-      confidence: classified.confidence,
+      predictedCollection: resolved.collection,
+      confidence: resolved.confidence,
       autoRouted: false,
-      reasonCategory: ambiguousRoute ? "ambiguous" : "low-confidence",
+      reasonCategory: "low-confidence",
       explicitCollectionProvided,
       outcome: "fallback"
     });
     return {
       classifierMeta,
-      earlyResult: buildAmbiguousRouteResult(classified, classifierMeta, ambiguousRoute)
+      earlyResult: buildLowConfidenceResult(resolved, classifierMeta)
     };
   }
   trackClassifierTelemetry({
     workspaceId,
-    predictedCollection: classified.collection,
-    confidence: classified.confidence,
+    predictedCollection: resolved.collection,
+    confidence: resolved.confidence,
     autoRouted: true,
     reasonCategory: "auto-routed",
     explicitCollectionProvided,
     outcome: "auto-routed"
   });
   return {
-    resolvedCollection: classified.collection,
+    resolvedCollection: resolved.collection,
     classifierMeta
   };
 }
@@ -2131,14 +2173,28 @@ var batchCaptureOutputSchema = z2.object({
     entryId: z2.string(),
     collection: z2.string(),
     name: z2.string(),
-    status: z2.enum(["draft", "committed", "proposed"])
+    status: z2.enum(["draft", "committed", "proposed"]),
+    classifiedBy: z2.enum(["llm", "heuristic", "explicit"]).optional(),
+    confidence: z2.number().optional(),
+    confidenceTier: z2.enum(["high", "medium", "low"]).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(),
@@ -2150,9 +2206,6 @@ function shouldAutoCommitCapture(autoCommit, governanceMode) {
   return autoCommit === true || autoCommit === void 0 && governanceMode === "open";
 }
 function registerSmartCaptureTools(server) {
-  const supportedCollections = new Set(
-    CLASSIFIABLE_COLLECTIONS.filter((slug) => PROFILES.has(slug))
-  );
   const captureTool = server.registerTool(
     "capture",
     {
@@ -2175,7 +2228,6 @@ function registerSmartCaptureTools(server) {
         name,
         description,
         classifierFlagOn,
-        supportedCollections,
         workspaceId: wsCtx.workspaceId,
         explicitCollectionProvided
       });
@@ -2642,7 +2694,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
     "batch-capture",
     {
       title: "Batch Capture",
-      description: "Create multiple knowledge entries in one call. Ideal for workspace setup, document ingestion, or any scenario where you need to capture many entries at once.\n\nEach entry is created independently \u2014 if one fails, the others still succeed. Returns a compact summary instead of per-entry quality scorecards.\n\nAuto-linking runs per entry but contradiction checks and readiness hints are skipped for speed. Use `quality 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.",
+      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 }
     },
@@ -2652,7 +2704,25 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
       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...`,
@@ -2672,17 +2742,43 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
             logger: "product-brain"
           });
         }
-        const profile = PROFILES.get(entry.collection) ?? FALLBACK_PROFILE;
-        const col = collCache.get(entry.collection);
+        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: entry.collection,
+            collection: resolvedSlug,
             entryId: "",
             ok: false,
             autoLinks: 0,
             status: "draft",
-            error: `Collection "${entry.collection}" not found`
+            classifiedBy,
+            confidence,
+            confidenceTier,
+            error: `Collection "${resolvedSlug}" not found`
           });
           continue;
         }
@@ -2705,7 +2801,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         }
         if (profile.inferField) {
           const inferred = profile.inferField({
-            collection: entry.collection,
+            collection: resolvedSlug,
             name: entry.name,
             description: entry.description,
             data,
@@ -2723,7 +2819,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         }
         try {
           const result = await mcpMutation("chain.createEntry", {
-            collectionSlug: entry.collection,
+            collectionSlug: resolvedSlug,
             entryId: entry.entryId ?? void 0,
             name: entry.name,
             status: "draft",
@@ -2742,7 +2838,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
             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, entry.collection, collIdToSlug.get(r.collectionId) ?? "unknown");
+                const conf = computeLinkConfidence(r, entry.name, entry.description, resolvedSlug, collIdToSlug.get(r.collectionId) ?? "unknown");
                 return {
                   ...r,
                   collSlug: collIdToSlug.get(r.collectionId) ?? "unknown",
@@ -2753,7 +2849,7 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
                 if (autoLinkCount >= MAX_AUTO_LINKS) break;
                 if (c.confidence < AUTO_LINK_CONFIDENCE_THRESHOLD) break;
                 if (!c.entryId) continue;
-                const { type: relationType } = inferRelationType(entry.collection, c.collSlug, profile);
+                const { type: relationType } = inferRelationType(resolvedSlug, c.collSlug, profile);
                 try {
                   await mcpMutation("chain.createEntryRelation", {
                     fromEntryId: finalEntryId,
@@ -2785,22 +2881,28 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
           }
           results.push({
             name: entry.name,
-            collection: entry.collection,
+            collection: resolvedSlug,
             entryId: finalEntryId,
             ok: true,
             autoLinks: autoLinkCount,
             status: finalStatus,
+            classifiedBy,
+            confidence,
+            confidenceTier,
             ...commitError ? { commitError } : {}
           });
         } catch (error) {
           const msg = error instanceof Error ? error.message : String(error);
           results.push({
             name: entry.name,
-            collection: entry.collection,
+            collection: resolvedSlug,
             entryId: "",
             ok: false,
             autoLinks: 0,
             status: "draft",
+            classifiedBy,
+            confidence,
+            confidenceTier,
             error: msg
           });
         }
@@ -2811,9 +2913,10 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
       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.`,
+        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);
@@ -2823,10 +2926,14 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
       }
       const lines = [
         `# Batch Capture Complete`,
-        `**${created.length}** created, **${failed.length}** failed out of ${entries.length} total.`,
+        `**${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.`
@@ -2841,12 +2948,38 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         lines.push("");
       }
       if (created.length > 0) {
-        lines.push("## Created");
-        for (const r of created) {
-          const linkNote = r.autoLinks > 0 ? `, ${r.autoLinks} auto-links` : "";
-          lines.push(`- **${r.entryId}**: ${r.name} [${r.collection}] \u2014 \`${r.status}\`${linkNote}`);
+        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");
@@ -2864,21 +2997,36 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
         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) {
+      if (entryIds.length > 0 || skippedLowConfidence.length > 0) {
         lines.push("");
         lines.push("## Next Steps");
-        lines.push(`- **Connect:** Run \`graph action=suggest\` on key entries to build the knowledge graph`);
+        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`);
         }
-        lines.push(`- **Quality:** Run \`quality action=check\` on individual entries to assess completeness`);
+        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 summary = failed.length > 0 ? `Batch captured ${created.length}/${entries.length} entries (${failed.length} failed, ${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft).` : `Batch captured ${created.length} entries successfully (${committed.length} committed, ${proposed.length} proposed, ${drafts.length} draft).`;
+      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 = created.length > 0 ? [
-        { tool: "graph", description: "Discover connections", parameters: { action: "suggest", entryId: created[0].entryId } },
-        ...firstDraft ? [{ tool: "commit-entry", description: "Commit first draft", parameters: { entryId: firstDraft.entryId } }] : []
-      ] : [];
+      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(
@@ -2888,14 +3036,27 @@ Use \`entries action=get\` to inspect the existing entry, or \`update-entry\` to
               entryId: r.entryId,
               collection: r.collection,
               name: r.name,
-              status: r.status
+              status: r.status,
+              ...r.classifiedBy ? { classifiedBy: r.classifiedBy } : {},
+              ...r.confidence != null ? { confidence: r.confidence } : {},
+              ...r.confidenceTier ? { confidenceTier: r.confidenceTier } : {}
             })),
             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),
@@ -3146,7 +3307,7 @@ export {
   CLASSIFIABLE_COLLECTIONS,
   classifyCollection,
   isClassificationAmbiguous,
-  STARTER_COLLECTIONS,
+  resolveCollection,
   success,
   failure,
   parseOrFail,
@@ -3156,6 +3317,7 @@ export {
   notFoundResult,
   validationResult,
   withEnvelope,
+  STARTER_COLLECTIONS,
   inferStrategyCategory,
   formatQualityReport,
   checkEntryQuality,
@@ -3169,4 +3331,4 @@ export {
   formatRubricCoaching,
   formatRubricVerdictSection
 };
-//# sourceMappingURL=chunk-UWILSX73.js.map
+//# sourceMappingURL=chunk-TH5AUVVM.js.map