@remnic/core 1.1.11 → 1.1.12

package/dist/chunk-4RA3C3EV.js

@@ -0,0 +1,60 @@
+// src/telemetry-transcript.ts
+var TELEMETRY_TURN_MARKER = /^\[(?:user|assistant|system)\]\s+\[(?:action|observation|state|reward|step|turn|frame)\s+\d+\]:/i;
+var BARE_TELEMETRY_MARKER = /^\[(?:action|observation|state|reward|step|turn|frame)\s+\d+\]:/i;
+var DURABLE_MEMORY_CUE_PHRASES = [
+  "remember",
+  "don't forget",
+  "prefer",
+  "preference",
+  "decided",
+  "decision",
+  "deadline",
+  "commitment",
+  "promise",
+  "my name",
+  "i am",
+  "i work",
+  "we use",
+  "correction",
+  "actually",
+  "always",
+  "never",
+  "when you"
+];
+function stripRolePrefix(line) {
+  return line.replace(/^\[(?:user|assistant|system)\]\s+/i, "").trim();
+}
+function isTelemetryMarkerLine(line) {
+  return TELEMETRY_TURN_MARKER.test(line) || BARE_TELEMETRY_MARKER.test(stripRolePrefix(line));
+}
+function isMechanicalTelemetryLine(line) {
+  const stripped = stripRolePrefix(line);
+  return isTelemetryMarkerLine(line) || /^(?:left|right|up|down|wait|noop|stop|start|forward|backward)$/i.test(stripped) || /^(?:active rules|objects on (?:the )?map|inventory|score|reward|position|location):?$/i.test(stripped) || /^rule `[^`]+`/i.test(stripped) || /^(?:[a-z][\w-]*|\w+ `[^`]+`)\s+\d+\s+steps?\s+(?:to\s+the\s+)?(?:left|right|up|down)\b/i.test(stripped);
+}
+function hasDurableMemoryCue(conversation) {
+  const lower = conversation.toLowerCase();
+  if (DURABLE_MEMORY_CUE_PHRASES.some((phrase) => lower.includes(phrase))) {
+    return true;
+  }
+  const ifIndex = lower.indexOf("if ");
+  return ifIndex >= 0 && lower.indexOf(" then", ifIndex + 3) >= 0;
+}
+function looksLikeMechanicalTelemetryTranscript(conversation) {
+  if (hasDurableMemoryCue(conversation)) return false;
+  const lines = conversation.split(/\n+/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length < 8) return false;
+  const markerLines = lines.filter((line) => isTelemetryMarkerLine(line)).length;
+  if (markerLines < 4) return false;
+  const mechanicalLines = lines.filter((line) => isMechanicalTelemetryLine(line)).length;
+  const mechanicalRatio = mechanicalLines / lines.length;
+  return mechanicalRatio >= 0.45;
+}
+
+export {
+  stripRolePrefix,
+  isTelemetryMarkerLine,
+  isMechanicalTelemetryLine,
+  hasDurableMemoryCue,
+  looksLikeMechanicalTelemetryTranscript
+};
+//# sourceMappingURL=chunk-4RA3C3EV.js.map

package/dist/chunk-4RA3C3EV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/telemetry-transcript.ts"],"sourcesContent":["const TELEMETRY_TURN_MARKER = /^\\[(?:user|assistant|system)\\]\\s+\\[(?:action|observation|state|reward|step|turn|frame)\\s+\\d+\\]:/i;\nconst BARE_TELEMETRY_MARKER = /^\\[(?:action|observation|state|reward|step|turn|frame)\\s+\\d+\\]:/i;\nconst DURABLE_MEMORY_CUE_PHRASES = [\n  \"remember\",\n  \"don't forget\",\n  \"prefer\",\n  \"preference\",\n  \"decided\",\n  \"decision\",\n  \"deadline\",\n  \"commitment\",\n  \"promise\",\n  \"my name\",\n  \"i am\",\n  \"i work\",\n  \"we use\",\n  \"correction\",\n  \"actually\",\n  \"always\",\n  \"never\",\n  \"when you\",\n];\n\nexport function stripRolePrefix(line: string): string {\n  return line.replace(/^\\[(?:user|assistant|system)\\]\\s+/i, \"\").trim();\n}\n\nexport function isTelemetryMarkerLine(line: string): boolean {\n  return TELEMETRY_TURN_MARKER.test(line) ||\n    BARE_TELEMETRY_MARKER.test(stripRolePrefix(line));\n}\n\nexport function isMechanicalTelemetryLine(line: string): boolean {\n  const stripped = stripRolePrefix(line);\n  return (\n    isTelemetryMarkerLine(line) ||\n    /^(?:left|right|up|down|wait|noop|stop|start|forward|backward)$/i.test(stripped) ||\n    /^(?:active rules|objects on (?:the )?map|inventory|score|reward|position|location):?$/i.test(stripped) ||\n    /^rule `[^`]+`/i.test(stripped) ||\n    /^(?:[a-z][\\w-]*|\\w+ `[^`]+`)\\s+\\d+\\s+steps?\\s+(?:to\\s+the\\s+)?(?:left|right|up|down)\\b/i.test(stripped)\n  );\n}\n\nexport function hasDurableMemoryCue(conversation: string): boolean {\n  const lower = conversation.toLowerCase();\n  if (DURABLE_MEMORY_CUE_PHRASES.some((phrase) => lower.includes(phrase))) {\n    return true;\n  }\n  const ifIndex = lower.indexOf(\"if \");\n  return ifIndex >= 0 && lower.indexOf(\" then\", ifIndex + 3) >= 0;\n}\n\nexport function looksLikeMechanicalTelemetryTranscript(\n  conversation: string,\n): boolean {\n  if (hasDurableMemoryCue(conversation)) return false;\n\n  const lines = conversation\n    .split(/\\n+/)\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0);\n  if (lines.length < 8) return false;\n\n  const markerLines = lines.filter((line) => isTelemetryMarkerLine(line)).length;\n  if (markerLines < 4) return false;\n\n  const mechanicalLines = lines.filter((line) => isMechanicalTelemetryLine(line)).length;\n  const mechanicalRatio = mechanicalLines / lines.length;\n  return mechanicalRatio >= 0.45;\n}\n"],"mappings":";AAAA,IAAM,wBAAwB;AAC9B,IAAM,wBAAwB;AAC9B,IAAM,6BAA6B;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,SAAS,gBAAgB,MAAsB;AACpD,SAAO,KAAK,QAAQ,sCAAsC,EAAE,EAAE,KAAK;AACrE;AAEO,SAAS,sBAAsB,MAAuB;AAC3D,SAAO,sBAAsB,KAAK,IAAI,KACpC,sBAAsB,KAAK,gBAAgB,IAAI,CAAC;AACpD;AAEO,SAAS,0BAA0B,MAAuB;AAC/D,QAAM,WAAW,gBAAgB,IAAI;AACrC,SACE,sBAAsB,IAAI,KAC1B,kEAAkE,KAAK,QAAQ,KAC/E,yFAAyF,KAAK,QAAQ,KACtG,iBAAiB,KAAK,QAAQ,KAC9B,0FAA0F,KAAK,QAAQ;AAE3G;AAEO,SAAS,oBAAoB,cAA+B;AACjE,QAAM,QAAQ,aAAa,YAAY;AACvC,MAAI,2BAA2B,KAAK,CAAC,WAAW,MAAM,SAAS,MAAM,CAAC,GAAG;AACvE,WAAO;AAAA,EACT;AACA,QAAM,UAAU,MAAM,QAAQ,KAAK;AACnC,SAAO,WAAW,KAAK,MAAM,QAAQ,SAAS,UAAU,CAAC,KAAK;AAChE;AAEO,SAAS,uCACd,cACS;AACT,MAAI,oBAAoB,YAAY,EAAG,QAAO;AAE9C,QAAM,QAAQ,aACX,MAAM,KAAK,EACX,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;AACnC,MAAI,MAAM,SAAS,EAAG,QAAO;AAE7B,QAAM,cAAc,MAAM,OAAO,CAAC,SAAS,sBAAsB,IAAI,CAAC,EAAE;AACxE,MAAI,cAAc,EAAG,QAAO;AAE5B,QAAM,kBAAkB,MAAM,OAAO,CAAC,SAAS,0BAA0B,IAAI,CAAC,EAAE;AAChF,QAAM,kBAAkB,kBAAkB,MAAM;AAChD,SAAO,mBAAmB;AAC5B;","names":[]}

package/dist/{chunk-EYNQTST2.js → chunk-4YM32CRU.js}

@@ -1,9 +1,9 @@
+import {
+  StorageManager
+} from "./chunk-3B6KIRBH.js";
 import {
   decideLifecycleTransition
 } from "./chunk-TBBDFYXW.js";
-import {
-  StorageManager
-} from "./chunk-MCC6KDQF.js";
 
 // src/maintenance/memory-governance.ts
 import path from "path";
@@ -718,4 +718,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-EYNQTST2.js.map
+//# sourceMappingURL=chunk-4YM32CRU.js.map

package/dist/{chunk-6AUUAZEX.js → chunk-5NXIJZFX.js}

@@ -11,7 +11,7 @@ import {
 // src/taxonomy/resolver.ts
 var DEFAULT_CATEGORY_ID = "facts";
 function resolveCategory(content, memoryCategory, taxonomy) {
-  const contentLower = content.toLowerCase();
+  const contentTokens = tokenizeKeywordText(content);
   const matches = taxonomy.categories.filter(
     (cat) => cat.memoryCategories.includes(memoryCategory)
   );
@@ -51,20 +51,24 @@ function resolveCategory(content, memoryCategory, taxonomy) {
   }
   const scored = matches.map((cat) => ({
     cat,
-    keywordScore: computeKeywordScore(contentLower, cat)
+    keywordScore: computeKeywordScoreForTokens(contentTokens, cat)
   }));
   scored.sort((a, b) => {
     if (b.keywordScore !== a.keywordScore) return b.keywordScore - a.keywordScore;
     return a.cat.priority - b.cat.priority;
   });
-  const best = scored[0];
+  const topScored = scored[0];
+  const best = topScored.keywordScore > 0 ? topScored : {
+    cat: selectFallbackCategory(matches) ?? topScored.cat,
+    keywordScore: 0
+  };
   const runnerUp = scored[1];
   const confidence = best.keywordScore > 0 && (!runnerUp || best.keywordScore > runnerUp.keywordScore) ? 0.9 : 0.7;
   const alternatives = taxonomy.categories.filter((c) => c.id !== best.cat.id).map((c) => ({
     categoryId: c.id,
     reason: c.description
   }));
-  const reason = best.keywordScore > 0 ? `Filing rules for "${best.cat.name}" matched content keywords (priority ${best.cat.priority})` : `Priority tie-break: "${best.cat.name}" has lowest priority number (${best.cat.priority})`;
+  const reason = best.keywordScore > 0 ? `Filing rules for "${best.cat.name}" matched content keywords (priority ${best.cat.priority})` : `No filing rules matched content keywords; using fallback category "${best.cat.name}"`;
   return {
     categoryId: best.cat.id,
     confidence,
@@ -72,17 +76,43 @@ function resolveCategory(content, memoryCategory, taxonomy) {
     alternatives
   };
 }
-function computeKeywordScore(contentLower, cat) {
+function computeKeywordScoreForTokens(contentTokens, cat) {
   let score = 0;
   const ruleText = [...cat.filingRules, cat.description].join(" ").toLowerCase();
-  const keywords = ruleText.split(/[^a-z0-9]+/).filter((w) => w.length >= 3);
+  const keywords = tokenizeKeywordText(ruleText);
   for (const kw of keywords) {
-    if (contentLower.includes(kw)) {
+    if (contentTokens.has(kw)) {
       score += 1;
     }
   }
   return score;
 }
+function tokenizeKeywordText(value) {
+  return new Set(
+    value.toLowerCase().split(/[^a-z0-9]+/).map((word) => word.trim()).filter((word) => word.length >= 3 && !TAXONOMY_KEYWORD_STOPWORDS.has(word))
+  );
+}
+function selectFallbackCategory(categories) {
+  return categories.find((cat) => cat.id === DEFAULT_CATEGORY_ID) ?? categories.find((cat) => {
+    const text = `${cat.id} ${cat.name} ${cat.description} ${cat.filingRules.join(" ")}`.toLowerCase();
+    return /\b(general|fallback)\b/.test(text);
+  });
+}
+var TAXONOMY_KEYWORD_STOPWORDS = /* @__PURE__ */ new Set([
+  "about",
+  "all",
+  "and",
+  "are",
+  "for",
+  "from",
+  "has",
+  "into",
+  "not",
+  "the",
+  "this",
+  "was",
+  "with"
+]);
 
 // src/direct-answer-wiring.ts
 async function tryDirectAnswer(input) {
@@ -147,4 +177,4 @@ export {
   resolveCategory,
   tryDirectAnswer
 };
-//# sourceMappingURL=chunk-6AUUAZEX.js.map
+//# sourceMappingURL=chunk-5NXIJZFX.js.map

package/dist/chunk-5NXIJZFX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/taxonomy/resolver.ts","../src/direct-answer-wiring.ts"],"sourcesContent":["/**\n * Resolver decision tree for the MECE taxonomy.\n *\n * Given extracted content and its MemoryCategory, determines which\n * taxonomy category the knowledge should be filed under.\n */\n\nimport type { MemoryCategory } from \"../types.js\";\nimport type { ResolverDecision, Taxonomy, TaxonomyCategory } from \"./types.js\";\n\nconst DEFAULT_CATEGORY_ID = \"facts\";\n\n/**\n * Resolve a piece of content to a taxonomy category.\n *\n * Algorithm:\n * 1. Find all taxonomy categories whose `memoryCategories` include\n *    the given `memoryCategory`.\n * 2. If exactly one match, return it with confidence 1.0.\n * 3. If multiple matches, prefer the strongest exact-token keyword\n *    overlap from filing rules. Use priority only as a tie-breaker.\n *    If no filing rules match, choose the explicit/default fallback\n *    category instead of letting low-priority generic terms win.\n * 4. If no match, fall back to the \"facts\" category (or first\n *    category if \"facts\" is absent) with low confidence.\n * 5. Always populate `alternatives` with other plausible categories.\n */\nexport function resolveCategory(\n  content: string,\n  memoryCategory: MemoryCategory,\n  taxonomy: Taxonomy,\n): ResolverDecision {\n  const contentTokens = tokenizeKeywordText(content);\n\n  // Step 1: find matching categories\n  const matches = taxonomy.categories.filter((cat) =>\n    cat.memoryCategories.includes(memoryCategory),\n  );\n\n  if (matches.length === 0) {\n    // No taxonomy category accepts this MemoryCategory — fall back\n    const fallback =\n      taxonomy.categories.find((c) => c.id === DEFAULT_CATEGORY_ID) ??\n      taxonomy.categories[0];\n    if (!fallback) {\n      return {\n        categoryId: DEFAULT_CATEGORY_ID,\n        confidence: 0,\n        reason: \"Taxonomy is empty; using default category\",\n        alternatives: [],\n      };\n    }\n    const alternatives = taxonomy.categories\n      .filter((c) => c.id !== fallback.id)\n      .map((c) => ({\n        categoryId: c.id,\n        reason: c.description,\n      }));\n    return {\n      categoryId: fallback.id,\n      confidence: 0.3,\n      reason: `No taxonomy category maps to MemoryCategory \"${memoryCategory}\"; falling back to \"${fallback.name}\"`,\n      alternatives,\n    };\n  }\n\n  if (matches.length === 1) {\n    const match = matches[0]!;\n    const alternatives = taxonomy.categories\n      .filter((c) => c.id !== match.id)\n      .map((c) => ({\n        categoryId: c.id,\n        reason: c.description,\n      }));\n    return {\n      categoryId: match.id,\n      confidence: 1.0,\n      reason: `Unique match: MemoryCategory \"${memoryCategory}\" maps to \"${match.name}\"`,\n      alternatives,\n    };\n  }\n\n  // Multiple matches — use filing rule keyword heuristics + priority\n  const scored = matches.map((cat) => ({\n    cat,\n    keywordScore: computeKeywordScoreForTokens(contentTokens, cat),\n  }));\n\n  // Sort by keyword score descending, then priority ascending (lower wins)\n  scored.sort((a, b) => {\n    if (b.keywordScore !== a.keywordScore) return b.keywordScore - a.keywordScore;\n    return a.cat.priority - b.cat.priority;\n  });\n\n  const topScored = scored[0]!;\n  const best = topScored.keywordScore > 0\n    ? topScored\n    : {\n        cat: selectFallbackCategory(matches) ?? topScored.cat,\n        keywordScore: 0,\n      };\n  const runnerUp = scored[1];\n\n  // Confidence is higher when keyword match clearly differentiates\n  const confidence =\n    best.keywordScore > 0 && (!runnerUp || best.keywordScore > runnerUp.keywordScore)\n      ? 0.9\n      : 0.7;\n\n  const alternatives = taxonomy.categories\n    .filter((c) => c.id !== best.cat.id)\n    .map((c) => ({\n      categoryId: c.id,\n      reason: c.description,\n    }));\n\n  const reason =\n    best.keywordScore > 0\n      ? `Filing rules for \"${best.cat.name}\" matched content keywords (priority ${best.cat.priority})`\n      : `No filing rules matched content keywords; using fallback category \"${best.cat.name}\"`;\n\n  return {\n    categoryId: best.cat.id,\n    confidence,\n    reason,\n    alternatives,\n  };\n}\n\n/**\n * Compute a simple keyword overlap score between content and\n * a category's filing rules + description.\n */\nfunction computeKeywordScoreForTokens(contentTokens: Set<string>, cat: TaxonomyCategory): number {\n  let score = 0;\n  const ruleText = [...cat.filingRules, cat.description]\n    .join(\" \")\n    .toLowerCase();\n\n  const keywords = tokenizeKeywordText(ruleText);\n\n  for (const kw of keywords) {\n    if (contentTokens.has(kw)) {\n      score += 1;\n    }\n  }\n  return score;\n}\n\nfunction tokenizeKeywordText(value: string): Set<string> {\n  return new Set(\n    value\n      .toLowerCase()\n      .split(/[^a-z0-9]+/)\n      .map((word) => word.trim())\n      .filter((word) => word.length >= 3 && !TAXONOMY_KEYWORD_STOPWORDS.has(word)),\n  );\n}\n\nfunction selectFallbackCategory(\n  categories: readonly TaxonomyCategory[],\n): TaxonomyCategory | undefined {\n  return categories.find((cat) => cat.id === DEFAULT_CATEGORY_ID) ??\n    categories.find((cat) => {\n      const text = `${cat.id} ${cat.name} ${cat.description} ${cat.filingRules.join(\" \")}`.toLowerCase();\n      return /\\b(general|fallback)\\b/.test(text);\n    });\n}\n\nconst TAXONOMY_KEYWORD_STOPWORDS = new Set([\n  \"about\",\n  \"all\",\n  \"and\",\n  \"are\",\n  \"for\",\n  \"from\",\n  \"has\",\n  \"into\",\n  \"not\",\n  \"the\",\n  \"this\",\n  \"was\",\n  \"with\",\n]);\n","/**\n * Direct-answer wiring (issue #518 slice 3).\n *\n * Binds the pure eligibility decision (`direct-answer.ts`) to the data\n * sources needed to build candidates: storage, trust-zones, taxonomy,\n * and importance scoring.  Kept as a separate module so that:\n *\n * - The eligibility layer stays pure and unit-testable without stores.\n * - Each caller injects its own source accessors.  The orchestrator\n *   binding is a follow-on slice; tests here use mock sources.\n * - The wiring is safe to ship alone — nothing calls `tryDirectAnswer`\n *   yet, so enabling this module's presence does not change recall\n *   behavior.  The next slice adds exactly one call site before QMD.\n *\n * Short-circuit contract:\n *\n * - When `config.recallDirectAnswerEnabled === false`, the function\n *   returns the eligibility verdict with reason `\"disabled\"` without\n *   touching any source accessor.  This is the documented default.\n * - When enabled, the wiring cheaply drops non-trusted-zone memories\n *   and ineligible taxonomy buckets before computing importance, so\n *   the eligibility module sees a pre-filtered candidate set.  The\n *   eligibility module still performs the same checks itself — this\n *   module is purely an I/O and prefiltering layer.\n */\n\nimport type { MemoryFile, PluginConfig } from \"./types.js\";\nimport type { TrustZoneName } from \"./trust-zones.js\";\nimport type { Taxonomy } from \"./taxonomy/types.js\";\nimport { resolveCategory } from \"./taxonomy/resolver.js\";\nimport { normalizeRecallTokens } from \"./recall-tokenization.js\";\nimport { throwIfAborted } from \"./abort-error.js\";\nimport {\n  isDirectAnswerEligible,\n  type DirectAnswerCandidate,\n  type DirectAnswerConfig,\n  type DirectAnswerResult,\n} from \"./direct-answer.js\";\n\n/**\n * Caller-provided accessors for candidate sourcing.  Decouples the\n * wiring from any specific storage / trust-zone / importance backend.\n */\nexport interface DirectAnswerSources {\n  /**\n   * List memories eligible to be considered for direct-answer.\n   * Callers are expected to return only active, non-superseded memories\n   * in the requested namespace; the wiring will cheaply re-filter on\n   * trust zone and taxonomy bucket and hand the rest to the eligibility\n   * module, which applies the full gate ladder.\n   */\n  listCandidateMemories(options: {\n    namespace: string;\n    abortSignal?: AbortSignal;\n  }): Promise<MemoryFile[]>;\n  /**\n   * Resolve the trust-zone record for a memory.  Returns `null` when\n   * the memory has no trust-zone record (treated as not trusted).\n   */\n  trustZoneFor(memoryId: string): Promise<TrustZoneName | null>;\n  /**\n   * Resolve a calibrated importance score in [0, 1] for a memory.\n   */\n  importanceFor(memory: MemoryFile): number;\n  /**\n   * Taxonomy used to classify memories into direct-answer buckets.\n   */\n  taxonomy: Taxonomy;\n}\n\nexport interface DirectAnswerWiringInput {\n  query: string;\n  namespace: string;\n  config: Pick<\n    PluginConfig,\n    | \"recallDirectAnswerEnabled\"\n    | \"recallDirectAnswerTokenOverlapFloor\"\n    | \"recallDirectAnswerImportanceFloor\"\n    | \"recallDirectAnswerAmbiguityMargin\"\n    | \"recallDirectAnswerEligibleTaxonomyBuckets\"\n  >;\n  sources: DirectAnswerSources;\n  queryEntityRefs?: string[];\n  abortSignal?: AbortSignal;\n}\n\n/**\n * Attempt direct-answer resolution.  Returns the eligibility verdict\n * produced by `isDirectAnswerEligible` with candidates materialized\n * from the caller-supplied sources.\n */\nexport async function tryDirectAnswer(\n  input: DirectAnswerWiringInput,\n): Promise<DirectAnswerResult> {\n  const { query, namespace, config, sources, queryEntityRefs, abortSignal } = input;\n\n  const eligibilityConfig: DirectAnswerConfig = {\n    enabled: config.recallDirectAnswerEnabled,\n    tokenOverlapFloor: config.recallDirectAnswerTokenOverlapFloor,\n    importanceFloor: config.recallDirectAnswerImportanceFloor,\n    ambiguityMargin: config.recallDirectAnswerAmbiguityMargin,\n    eligibleTaxonomyBuckets: config.recallDirectAnswerEligibleTaxonomyBuckets,\n  };\n\n  // Short-circuit disabled case before touching any I/O.\n  if (!eligibilityConfig.enabled) {\n    return isDirectAnswerEligible({\n      query,\n      candidates: [],\n      config: eligibilityConfig,\n      queryEntityRefs,\n    });\n  }\n\n  // Short-circuit empty-query case before any I/O.  isDirectAnswerEligible\n  // deterministically returns reason \"empty-query\" when the query\n  // normalizes to zero searchable tokens; there's no point materializing\n  // candidates just to reach the same verdict, and doing so would\n  // surface avoidable upstream errors for requests that should exit\n  // immediately.\n  if (normalizeRecallTokens(query).length === 0) {\n    return isDirectAnswerEligible({\n      query,\n      candidates: [],\n      config: eligibilityConfig,\n      queryEntityRefs,\n    });\n  }\n\n  throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n  const memories = await sources.listCandidateMemories({ namespace, abortSignal });\n  throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n  const candidates: DirectAnswerCandidate[] = [];\n\n  for (const memory of memories) {\n    // Throw rather than returning a partial verdict — a mid-loop abort\n    // that left competing candidates unprocessed could otherwise surface\n    // a spurious \"eligible\" result that the ambiguity gate never got a\n    // chance to reject.  The check repeats after every await so an\n    // abort that lands during the in-flight I/O on the final memory\n    // (after which no further iteration would exist) still stops us.\n    throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n\n    const trustZone = await sources.trustZoneFor(memory.frontmatter.id);\n    throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n\n    // Cheap pre-filter: non-trusted memories can't qualify, so skip\n    // taxonomy and importance resolution for them.\n    if (trustZone !== \"trusted\") continue;\n\n    const decision = resolveCategory(\n      memory.content,\n      memory.frontmatter.category,\n      sources.taxonomy,\n    );\n    const taxonomyBucket = decision.categoryId;\n    if (!eligibilityConfig.eligibleTaxonomyBuckets.includes(taxonomyBucket)) continue;\n\n    const importanceScore = sources.importanceFor(memory);\n\n    candidates.push({\n      memory,\n      trustZone,\n      taxonomyBucket,\n      importanceScore,\n    });\n  }\n\n  // Final check — if abort landed during the trust-zone await for the\n  // last memory, the loop condition no longer fires.  Guard before we\n  // hand candidates to the eligibility gate.\n  throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n\n  return isDirectAnswerEligible({\n    query,\n    candidates,\n    config: eligibilityConfig,\n    queryEntityRefs,\n  });\n}\n"],"mappings":";;;;;;;;;;;AAUA,IAAM,sBAAsB;AAiBrB,SAAS,gBACd,SACA,gBACA,UACkB;AAClB,QAAM,gBAAgB,oBAAoB,OAAO;AAGjD,QAAM,UAAU,SAAS,WAAW;AAAA,IAAO,CAAC,QAC1C,IAAI,iBAAiB,SAAS,cAAc;AAAA,EAC9C;AAEA,MAAI,QAAQ,WAAW,GAAG;AAExB,UAAM,WACJ,SAAS,WAAW,KAAK,CAAC,MAAM,EAAE,OAAO,mBAAmB,KAC5D,SAAS,WAAW,CAAC;AACvB,QAAI,CAAC,UAAU;AACb,aAAO;AAAA,QACL,YAAY;AAAA,QACZ,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,cAAc,CAAC;AAAA,MACjB;AAAA,IACF;AACA,UAAMA,gBAAe,SAAS,WAC3B,OAAO,CAAC,MAAM,EAAE,OAAO,SAAS,EAAE,EAClC,IAAI,CAAC,OAAO;AAAA,MACX,YAAY,EAAE;AAAA,MACd,QAAQ,EAAE;AAAA,IACZ,EAAE;AACJ,WAAO;AAAA,MACL,YAAY,SAAS;AAAA,MACrB,YAAY;AAAA,MACZ,QAAQ,gDAAgD,cAAc,uBAAuB,SAAS,IAAI;AAAA,MAC1G,cAAAA;AAAA,IACF;AAAA,EACF;AAEA,MAAI,QAAQ,WAAW,GAAG;AACxB,UAAM,QAAQ,QAAQ,CAAC;AACvB,UAAMA,gBAAe,SAAS,WAC3B,OAAO,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,EAC/B,IAAI,CAAC,OAAO;AAAA,MACX,YAAY,EAAE;AAAA,MACd,QAAQ,EAAE;AAAA,IACZ,EAAE;AACJ,WAAO;AAAA,MACL,YAAY,MAAM;AAAA,MAClB,YAAY;AAAA,MACZ,QAAQ,iCAAiC,cAAc,cAAc,MAAM,IAAI;AAAA,MAC/E,cAAAA;AAAA,IACF;AAAA,EACF;AAGA,QAAM,SAAS,QAAQ,IAAI,CAAC,SAAS;AAAA,IACnC;AAAA,IACA,cAAc,6BAA6B,eAAe,GAAG;AAAA,EAC/D,EAAE;AAGF,SAAO,KAAK,CAAC,GAAG,MAAM;AACpB,QAAI,EAAE,iBAAiB,EAAE,aAAc,QAAO,EAAE,eAAe,EAAE;AACjE,WAAO,EAAE,IAAI,WAAW,EAAE,IAAI;AAAA,EAChC,CAAC;AAED,QAAM,YAAY,OAAO,CAAC;AAC1B,QAAM,OAAO,UAAU,eAAe,IAClC,YACA;AAAA,IACE,KAAK,uBAAuB,OAAO,KAAK,UAAU;AAAA,IAClD,cAAc;AAAA,EAChB;AACJ,QAAM,WAAW,OAAO,CAAC;AAGzB,QAAM,aACJ,KAAK,eAAe,MAAM,CAAC,YAAY,KAAK,eAAe,SAAS,gBAChE,MACA;AAEN,QAAM,eAAe,SAAS,WAC3B,OAAO,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,EAAE,EAClC,IAAI,CAAC,OAAO;AAAA,IACX,YAAY,EAAE;AAAA,IACd,QAAQ,EAAE;AAAA,EACZ,EAAE;AAEJ,QAAM,SACJ,KAAK,eAAe,IAChB,qBAAqB,KAAK,IAAI,IAAI,wCAAwC,KAAK,IAAI,QAAQ,MAC3F,sEAAsE,KAAK,IAAI,IAAI;AAEzF,SAAO;AAAA,IACL,YAAY,KAAK,IAAI;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAMA,SAAS,6BAA6B,eAA4B,KAA+B;AAC/F,MAAI,QAAQ;AACZ,QAAM,WAAW,CAAC,GAAG,IAAI,aAAa,IAAI,WAAW,EAClD,KAAK,GAAG,EACR,YAAY;AAEf,QAAM,WAAW,oBAAoB,QAAQ;AAE7C,aAAW,MAAM,UAAU;AACzB,QAAI,cAAc,IAAI,EAAE,GAAG;AACzB,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,oBAAoB,OAA4B;AACvD,SAAO,IAAI;AAAA,IACT,MACG,YAAY,EACZ,MAAM,YAAY,EAClB,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,OAAO,CAAC,SAAS,KAAK,UAAU,KAAK,CAAC,2BAA2B,IAAI,IAAI,CAAC;AAAA,EAC/E;AACF;AAEA,SAAS,uBACP,YAC8B;AAC9B,SAAO,WAAW,KAAK,CAAC,QAAQ,IAAI,OAAO,mBAAmB,KAC5D,WAAW,KAAK,CAAC,QAAQ;AACvB,UAAM,OAAO,GAAG,IAAI,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,YAAY,KAAK,GAAG,CAAC,GAAG,YAAY;AACjG,WAAO,yBAAyB,KAAK,IAAI;AAAA,EAC3C,CAAC;AACL;AAEA,IAAM,6BAA6B,oBAAI,IAAI;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;;;AC5FD,eAAsB,gBACpB,OAC6B;AAC7B,QAAM,EAAE,OAAO,WAAW,QAAQ,SAAS,iBAAiB,YAAY,IAAI;AAE5E,QAAM,oBAAwC;AAAA,IAC5C,SAAS,OAAO;AAAA,IAChB,mBAAmB,OAAO;AAAA,IAC1B,iBAAiB,OAAO;AAAA,IACxB,iBAAiB,OAAO;AAAA,IACxB,yBAAyB,OAAO;AAAA,EAClC;AAGA,MAAI,CAAC,kBAAkB,SAAS;AAC9B,WAAO,uBAAuB;AAAA,MAC5B;AAAA,MACA,YAAY,CAAC;AAAA,MACb,QAAQ;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AAQA,MAAI,sBAAsB,KAAK,EAAE,WAAW,GAAG;AAC7C,WAAO,uBAAuB;AAAA,MAC5B;AAAA,MACA,YAAY,CAAC;AAAA,MACb,QAAQ;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AAEA,iBAAe,aAAa,8BAA8B;AAC1D,QAAM,WAAW,MAAM,QAAQ,sBAAsB,EAAE,WAAW,YAAY,CAAC;AAC/E,iBAAe,aAAa,8BAA8B;AAC1D,QAAM,aAAsC,CAAC;AAE7C,aAAW,UAAU,UAAU;AAO7B,mBAAe,aAAa,8BAA8B;AAE1D,UAAM,YAAY,MAAM,QAAQ,aAAa,OAAO,YAAY,EAAE;AAClE,mBAAe,aAAa,8BAA8B;AAI1D,QAAI,cAAc,UAAW;AAE7B,UAAM,WAAW;AAAA,MACf,OAAO;AAAA,MACP,OAAO,YAAY;AAAA,MACnB,QAAQ;AAAA,IACV;AACA,UAAM,iBAAiB,SAAS;AAChC,QAAI,CAAC,kBAAkB,wBAAwB,SAAS,cAAc,EAAG;AAEzE,UAAM,kBAAkB,QAAQ,cAAc,MAAM;AAEpD,eAAW,KAAK;AAAA,MACd;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAKA,iBAAe,aAAa,8BAA8B;AAE1D,SAAO,uBAAuB;AAAA,IAC5B;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,EACF,CAAC;AACH;","names":["alternatives"]}