@remnic/core 9.63.1 → 9.63.3

package/dist/{chunk-UKBIB3FP.js → chunk-KWN6NOHQ.js}

@@ -1,7 +1,7 @@
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES
-} from "./chunk-7CJO52ET.js";
+} from "./chunk-JJ7JW62R.js";
 import {
   SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH
 } from "./chunk-XDL5CYZN.js";
@@ -343,4 +343,4 @@ export {
   parseSupportPassportModelJob,
   SupportPassportModelBridge
 };
-//# sourceMappingURL=chunk-UKBIB3FP.js.map
+//# sourceMappingURL=chunk-KWN6NOHQ.js.map

package/dist/{chunk-227UFSEQ.js → chunk-LEPOP46W.js}

@@ -1,6 +1,3 @@
-import {
-  failOpenFaissHealth
-} from "./chunk-ET356KSB.js";
 import {
   rebuildConversationChunksFailOpen,
   upsertConversationChunksFailOpen
@@ -9,6 +6,9 @@ import {
   searchConversationIndex,
   searchConversationIndexFaissFailOpen
 } from "./chunk-A7Q43EUZ.js";
+import {
+  failOpenFaissHealth
+} from "./chunk-ET356KSB.js";
 
 // src/conversation-index/backend.ts
 function createConversationIndexBackend(options) {
@@ -235,4 +235,4 @@ function createFaissBackend(getFaiss) {
 export {
   createConversationIndexBackend
 };
-//# sourceMappingURL=chunk-227UFSEQ.js.map
+//# sourceMappingURL=chunk-LEPOP46W.js.map

package/dist/{chunk-SHSJP4D6.js → chunk-LZCSOUJ7.js}

@@ -1,6 +1,6 @@
 import {
   resolveCorpusNamespaceRoots
-} from "./chunk-ALKRPLWB.js";
+} from "./chunk-DNRTKO2U.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-MZWSOLMT.js";
@@ -200,4 +200,4 @@ async function readAggregateExtractionWatermark(options) {
 export {
   readAggregateExtractionWatermark
 };
-//# sourceMappingURL=chunk-SHSJP4D6.js.map
+//# sourceMappingURL=chunk-LZCSOUJ7.js.map

package/dist/{chunk-256FBCVX.js → chunk-M4AHBM72.js}

@@ -1,3 +1,9 @@
+import {
+  LcmWorkQueue
+} from "./chunk-TPDBFYEG.js";
+import {
+  assembleCompressedHistoryWithTrace
+} from "./chunk-UXPUUL3G.js";
 import {
   ensureLcmStateDir,
   openLcmDatabase
@@ -11,12 +17,6 @@ import {
 import {
   LcmDag
 } from "./chunk-7N4KAIGN.js";
-import {
-  LcmWorkQueue
-} from "./chunk-TPDBFYEG.js";
-import {
-  assembleCompressedHistoryWithTrace
-} from "./chunk-UXPUUL3G.js";
 import {
   estimateTokenCount
 } from "./chunk-TOTT6S2V.js";
@@ -568,4 +568,4 @@ export {
   extractLcmConfig,
   LcmEngine
 };
-//# sourceMappingURL=chunk-256FBCVX.js.map
+//# sourceMappingURL=chunk-M4AHBM72.js.map

package/dist/{chunk-5PFGMO33.js → chunk-MEW53VQJ.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-G73MCJKL.js";
 import {
   normalizeRecallTokens
-} from "./chunk-DJ7HMNSL.js";
+} from "./chunk-YCVB7X56.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -290,4 +290,4 @@ export {
   deriveHarmonicRecords,
   persistHarmonicRecords
 };
-//# sourceMappingURL=chunk-5PFGMO33.js.map
+//# sourceMappingURL=chunk-MEW53VQJ.js.map

package/dist/{chunk-DCUMFQYM.js → chunk-ML3U4KPR.js}

@@ -12,7 +12,7 @@ import {
 import {
   expandUnsegmentableRecallNGrams,
   isUnsegmentableRecallChar
-} from "./chunk-DJ7HMNSL.js";
+} from "./chunk-YCVB7X56.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -776,4 +776,4 @@ export {
   resolveOramaCollectionDbFilePath,
   OramaBackend
 };
-//# sourceMappingURL=chunk-DCUMFQYM.js.map
+//# sourceMappingURL=chunk-ML3U4KPR.js.map

package/dist/{chunk-UDL4DNBM.js → chunk-MR5HWQHS.js}

@@ -1,7 +1,7 @@
 import {
   SupportPassportCreateGrantRequestSchema,
   defineOperation
-} from "./chunk-7CJO52ET.js";
+} from "./chunk-JJ7JW62R.js";
 import {
   SupportPassportCardCategorySchema,
   SupportPassportMemoryIdSchema,
@@ -220,4 +220,4 @@ var supportPassportGrantAskOperation = defineOperation({
     result: await ctx.service.supportPassportAskGrant(grantId, secret, question, ctx.abortSignal)
   })
 });
-//# sourceMappingURL=chunk-UDL4DNBM.js.map
+//# sourceMappingURL=chunk-MR5HWQHS.js.map

package/dist/{chunk-H7PRHUBD.js → chunk-NRLELHAY.js}

@@ -1,7 +1,7 @@
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
-} from "./chunk-DJ7HMNSL.js";
+} from "./chunk-YCVB7X56.js";
 import {
   assertIsoRecordedAt,
   assertSafePathSegment,
@@ -182,4 +182,4 @@ export {
   searchWorkProductLedgerEntries,
   getWorkProductLedgerStatus
 };
-//# sourceMappingURL=chunk-H7PRHUBD.js.map
+//# sourceMappingURL=chunk-NRLELHAY.js.map

package/dist/{chunk-ZS4JADYY.js → chunk-OW7NVMGQ.js}

@@ -1,7 +1,7 @@
 import {
   resolveWorkProductLedgerDir,
   validateWorkProductLedgerEntry
-} from "./chunk-H7PRHUBD.js";
+} from "./chunk-NRLELHAY.js";
 import {
   TranscriptManager
 } from "./chunk-AM4T6CHX.js";
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-ZS4JADYY.js.map
+//# sourceMappingURL=chunk-OW7NVMGQ.js.map

package/dist/{chunk-U5LYM2NS.js → chunk-PADG72LJ.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-5JMAGU26.js";
 import {
   runPostConsolidationMaterialize
-} from "./chunk-MMM7SDOJ.js";
+} from "./chunk-WDUG2CH3.js";
 import {
   isSemanticConsolidationLlmOperator
 } from "./chunk-G7D6GZ5J.js";
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
-} from "./chunk-DJ7HMNSL.js";
+} from "./chunk-YCVB7X56.js";
 import {
   resolvePipelineProcessingCapabilities
 } from "./chunk-JUOZ62Y7.js";
@@ -220,4 +220,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-U5LYM2NS.js.map
+//# sourceMappingURL=chunk-PADG72LJ.js.map

package/dist/{chunk-6GGTATZF.js → chunk-PYIR4SSB.js}

@@ -1,7 +1,8 @@
 import {
+  isUnsegmentableRecallChar,
   normalizeRecallTokenSet,
   normalizeRecallTokens
-} from "./chunk-DJ7HMNSL.js";
+} from "./chunk-YCVB7X56.js";
 
 // src/direct-answer.ts
 var FILTER_LABELS = {
@@ -57,8 +58,7 @@ var PROMPT_RECALL_WORDS = /* @__PURE__ */ new Set([
   "\u0432\u043A\u043B\u044E\u0447\u0438"
 ]);
 function hasUnsegmentableRecallChar(token) {
-  if (token.includes("\u30FC") || token.includes("\uFF70")) return true;
-  return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(token);
+  return [...token].some((ch) => isUnsegmentableRecallChar(ch));
 }
 function requiredCjkPhraseTokens(query) {
   const phrases = /* @__PURE__ */ new Set();
@@ -356,4 +356,4 @@ export {
   FILTER_LABELS,
   isDirectAnswerEligible
 };
-//# sourceMappingURL=chunk-6GGTATZF.js.map
+//# sourceMappingURL=chunk-PYIR4SSB.js.map

package/dist/chunk-PYIR4SSB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/direct-answer.ts"],"sourcesContent":["/**\n * Direct-answer retrieval tier eligibility (issue #518 slice 2).\n *\n * This module is a pure decision layer.  It takes a query, a set of\n * caller-resolved candidates (each already decorated with trust-zone,\n * taxonomy-bucket, and importance information), and the direct-answer\n * config, then returns an eligibility verdict.\n *\n * Keeping the module pure means:\n *\n * - Tests do not need a trust-zones store, taxonomy resolver, or importance\n *   scorer on disk.\n * - Slice 3 (retrieval.ts wiring) is responsible for resolving those signals\n *   before calling in; the wiring layer decides where candidates come from\n *   (entity index, token prefilter, etc.).  This module only decides\n *   whether the surfaced candidates add up to a confident direct answer.\n *\n * Not wired into retrieval yet — see slice 3.\n */\n\nimport {\n  isUnsegmentableRecallChar as isUnsegmentableRecallCodepoint,\n  normalizeRecallTokenSet,\n  normalizeRecallTokens,\n} from \"./recall-tokenization.js\";\nimport type { TrustZoneName } from \"./trust-zones.js\";\nimport type { MemoryFile, MemoryStatus } from \"./types.js\";\n\n/**\n * Caller-supplied candidate.\n *\n * `trustZone`, `taxonomyBucket`, and `importanceScore` are resolved outside\n * this module because each comes from a different subsystem.  Passing them\n * as inputs keeps the function deterministic and easy to unit-test.\n *\n * `matchScore` is optional; if omitted, candidates are ranked by\n * token-overlap ratio.  Callers that already computed a better ranking\n * score (e.g. BM25, vector similarity) can supply it to drive the\n * ambiguity check.\n */\nexport interface DirectAnswerCandidate {\n  memory: MemoryFile;\n  trustZone: TrustZoneName | null;\n  taxonomyBucket: string | null;\n  importanceScore: number;\n  matchScore?: number;\n}\n\nexport interface DirectAnswerConfig {\n  enabled: boolean;\n  tokenOverlapFloor: number;\n  importanceFloor: number;\n  ambiguityMargin: number;\n  eligibleTaxonomyBuckets: string[];\n}\n\nexport interface DirectAnswerInput {\n  query: string;\n  candidates: DirectAnswerCandidate[];\n  config: DirectAnswerConfig;\n  /**\n   * Optional entity-ref hints resolved from the query upstream.  When\n   * supplied, a candidate with a set `entityRef` must match one of these\n   * (case-insensitive) to remain eligible.  Candidates without an\n   * `entityRef` are allowed through regardless.\n   */\n  queryEntityRefs?: string[];\n}\n\nexport type DirectAnswerReason =\n  | \"disabled\"\n  | \"empty-query\"\n  | \"no-candidates\"\n  | \"no-eligible-candidates\"\n  | \"below-token-overlap-floor\"\n  | \"ambiguous\"\n  | \"eligible\";\n\nexport interface DirectAnswerResult {\n  eligible: boolean;\n  reason: DirectAnswerReason;\n  /** Winning candidate when eligible. */\n  winner?: DirectAnswerCandidate;\n  /** Computed token-overlap ratio (0..1) of the winner. */\n  tokenOverlap?: number;\n  /**\n   * Human-readable summary suitable for\n   * `RecallTierExplain.tierReason`.\n   */\n  narrative: string;\n  /**\n   * Filter labels that eliminated at least one candidate along the way.\n   * Populated regardless of eligibility so the caller can surface the\n   * narrowing steps in `RecallTierExplain.filteredBy`.\n   */\n  filteredBy: string[];\n}\n\n/** Filter labels — exported so callers and tests can match them structurally. */\nexport const FILTER_LABELS = {\n  nonActiveStatus: \"non-active-status\",\n  notTrustedZone: \"not-trusted-zone\",\n  ineligibleTaxonomyBucket: \"ineligible-taxonomy-bucket\",\n  belowImportanceFloor: \"below-importance-floor\",\n  entityRefMismatch: \"entity-ref-mismatch\",\n  belowTokenOverlapFloor: \"below-token-overlap-floor\",\n} as const;\n\nconst PROMPT_RECALL_WORDS = new Set([\n  \"what\",\n  \"who\",\n  \"where\",\n  \"when\",\n  \"why\",\n  \"how\",\n  \"is\",\n  \"are\",\n  \"was\",\n  \"were\",\n  \"do\",\n  \"does\",\n  \"did\",\n  \"find\",\n  \"get\",\n  \"show\",\n  \"search\",\n  \"lookup\",\n  \"recall\",\n  \"remember\",\n  \"list\",\n  \"status\",\n  \"include\",\n  \"tell\",\n  \"me\",\n  \"give\",\n  \"about\",\n  \"please\",\n  \"the\",\n  \"and\",\n  \"for\",\n  \"with\",\n  \"from\",\n  \"into\",\n  \"that\",\n  \"this\",\n  \"найди\",\n  \"найти\",\n  \"поиск\",\n  \"покажи\",\n  \"статус\",\n  \"включи\",\n]);\n\ninterface ScoredCandidate {\n  candidate: DirectAnswerCandidate;\n  tokenOverlap: number;\n  requiredTokenMismatch: boolean;\n}\n\nfunction hasUnsegmentableRecallChar(token: string): boolean {\n  return [...token].some((ch) => isUnsegmentableRecallCodepoint(ch));\n}\n\nfunction requiredCjkPhraseTokens(query: string): string[] {\n  const phrases = new Set<string>();\n  let segment = \"\";\n\n  const addPhrase = (phrase: string) => {\n    if ([...phrase].length >= 4) {\n      phrases.add(phrase);\n    }\n  };\n\n  const flushSegment = () => {\n    let buffered = \"\";\n    for (const run of segment.split(/\\s+/)) {\n      if (!run) continue;\n      if ([...run].length >= 4) {\n        addPhrase(buffered);\n        buffered = \"\";\n        addPhrase(run);\n        continue;\n      }\n      buffered += run;\n    }\n    addPhrase(buffered);\n    segment = \"\";\n  };\n\n  for (const ch of query.toLowerCase().normalize(\"NFC\")) {\n    if (hasUnsegmentableRecallChar(ch)) {\n      segment += ch;\n      continue;\n    }\n    if (/\\p{M}/u.test(ch) && segment.length > 0 && !/\\s$/u.test(segment)) {\n      segment += ch;\n      continue;\n    }\n    if (/\\s/u.test(ch)) {\n      segment += \" \";\n      continue;\n    }\n    flushSegment();\n  }\n  flushSegment();\n\n  return [...phrases];\n}\n\nfunction requiredMixedScriptTokens(query: string): string[] {\n  const required = new Set<string>();\n  const parts: string[] = [];\n  let segment = \"\";\n\n  const flushSegment = () => {\n    if (segment) {\n      parts.push(segment);\n    }\n    segment = \"\";\n  };\n\n  const segmentableRecallTokens = (value: string) => {\n    const tokens = new Set<string>();\n    let segment = \"\";\n    const flushSegmentableSegment = () => {\n      for (const token of normalizeRecallTokenSet(segment, [], { minTokenLength: 1 })) {\n        tokens.add(token);\n      }\n      segment = \"\";\n    };\n\n    for (const ch of value) {\n      if (/[\\p{L}\\p{N}]/u.test(ch) && !hasUnsegmentableRecallChar(ch)) {\n        segment += ch;\n        continue;\n      }\n      if (/\\p{M}/u.test(ch) && segment.length > 0) {\n        segment += ch;\n        continue;\n      }\n      flushSegmentableSegment();\n    }\n    flushSegmentableSegment();\n    return tokens;\n  };\n\n  const hasRequiredSegmentableToken = (value: string) => {\n    return segmentableRecallTokens(value).size > 0;\n  };\n\n  const hasBoundarySegmentableToken = (value: string) => {\n    for (const token of segmentableRecallTokens(value)) {\n      if (PROMPT_RECALL_WORDS.has(token)) {\n        continue;\n      }\n      const hasNonAsciiCodepoint = [...token].some((ch) => (ch.codePointAt(0) ?? 0) > 0x7f);\n      if (token.length >= 3 || /\\p{N}/u.test(token) || hasNonAsciiCodepoint) {\n        return true;\n      }\n    }\n    return false;\n  };\n\n  const addRequiredTokens = (value: string) => {\n    for (const token of normalizeRecallTokenSet(value, [], { minTokenLength: 1 })) {\n      required.add(token);\n    }\n  };\n\n  for (const ch of query.toLowerCase().normalize(\"NFC\")) {\n    if (/[\\p{L}\\p{N}\\p{M}]/u.test(ch) || hasUnsegmentableRecallChar(ch)) {\n      segment += ch;\n      continue;\n    }\n    flushSegment();\n  }\n  flushSegment();\n\n  for (const part of parts) {\n    if (hasUnsegmentableRecallChar(part) && hasRequiredSegmentableToken(part)) {\n      addRequiredTokens(part);\n    }\n  }\n\n  for (let i = 0; i < parts.length - 1; i += 1) {\n    const current = parts[i];\n    const next = parts[i + 1];\n    const currentHasUnsegmentable = hasUnsegmentableRecallChar(current);\n    const nextHasUnsegmentable = hasUnsegmentableRecallChar(next);\n    if (currentHasUnsegmentable === nextHasUnsegmentable) {\n      continue;\n    }\n    const segmentablePart = currentHasUnsegmentable ? next : current;\n    if (!hasBoundarySegmentableToken(segmentablePart)) {\n      continue;\n    }\n    addRequiredTokens(current);\n    addRequiredTokens(next);\n  }\n\n  for (let i = 1; i < parts.length - 1; i += 1) {\n    const prev = parts[i - 1];\n    const current = parts[i];\n    const next = parts[i + 1];\n    if (!hasUnsegmentableRecallChar(prev) || hasUnsegmentableRecallChar(current) || !hasUnsegmentableRecallChar(next)) {\n      continue;\n    }\n    if (!hasRequiredSegmentableToken(current)) {\n      continue;\n    }\n    addRequiredTokens(prev);\n    addRequiredTokens(current);\n    addRequiredTokens(next);\n  }\n\n  return [...required];\n}\n\nfunction requiredSegmentableUnicodeTokens(queryTokens: Set<string>): string[] {\n  const segmentableTokens = [...queryTokens].filter((token) => !hasUnsegmentableRecallChar(token));\n  const hasSegmentableUnicodeToken = segmentableTokens.some((token) =>\n    [...token].some((ch) => (ch.codePointAt(0) ?? 0) > 0x7f)\n  );\n  if (!hasSegmentableUnicodeToken) {\n    return [];\n  }\n  return segmentableTokens.filter((token) => {\n    if (PROMPT_RECALL_WORDS.has(token)) {\n      return false;\n    }\n    const hasNonAsciiCodepoint = [...token].some((ch) => (ch.codePointAt(0) ?? 0) > 0x7f);\n    if (hasNonAsciiCodepoint) {\n      return true;\n    }\n    if (!/^[a-z0-9]+$/u.test(token)) {\n      return false;\n    }\n    return token.length >= 3 || /\\p{N}/u.test(token);\n  });\n}\n\nfunction countTokenOverlap(queryTokens: Set<string>, valueTokens: Set<string>): number {\n  let matches = 0;\n  for (const token of queryTokens) {\n    if (valueTokens.has(token)) matches += 1;\n  }\n  return matches;\n}\n\n/**\n * Determine whether a query can be served by the direct-answer tier.\n *\n * Decision ladder, in order:\n *\n *   1. config.enabled === false → \"disabled\"\n *   2. empty query tokens → \"empty-query\"\n *   3. empty candidates → \"no-candidates\"\n *   4. hard filters drop all candidates → \"no-eligible-candidates\"\n *   5. token-overlap floor drops all → \"below-token-overlap-floor\"\n *   6. top two candidates within ambiguityMargin → \"ambiguous\"\n *   7. otherwise → \"eligible\"\n */\nexport function isDirectAnswerEligible(input: DirectAnswerInput): DirectAnswerResult {\n  const { query, candidates, config, queryEntityRefs } = input;\n\n  if (!config.enabled) {\n    return {\n      eligible: false,\n      reason: \"disabled\",\n      narrative: \"direct-answer tier is disabled\",\n      filteredBy: [],\n    };\n  }\n\n  const queryTokens = new Set(normalizeRecallTokens(query));\n  if (queryTokens.size === 0) {\n    return {\n      eligible: false,\n      reason: \"empty-query\",\n      narrative: \"query has no searchable tokens after normalization\",\n      filteredBy: [],\n    };\n  }\n\n  if (candidates.length === 0) {\n    return {\n      eligible: false,\n      reason: \"no-candidates\",\n      narrative: \"no candidates supplied\",\n      filteredBy: [],\n    };\n  }\n\n  const filteredBy: string[] = [];\n  let working: DirectAnswerCandidate[] = candidates;\n\n  working = applyFilter(working, filteredBy, FILTER_LABELS.nonActiveStatus, (c) => {\n    const status: MemoryStatus = c.memory.frontmatter.status ?? \"active\";\n    return status === \"active\";\n  });\n\n  working = applyFilter(working, filteredBy, FILTER_LABELS.notTrustedZone, (c) => c.trustZone === \"trusted\");\n\n  working = applyFilter(\n    working,\n    filteredBy,\n    FILTER_LABELS.ineligibleTaxonomyBucket,\n    (c) => c.taxonomyBucket !== null && config.eligibleTaxonomyBuckets.includes(c.taxonomyBucket)\n  );\n\n  working = applyFilter(working, filteredBy, FILTER_LABELS.belowImportanceFloor, (c) => {\n    if (c.memory.frontmatter.verificationState === \"user_confirmed\") return true;\n    return c.importanceScore >= config.importanceFloor;\n  });\n\n  if (queryEntityRefs && queryEntityRefs.length > 0) {\n    const normRefs = new Set(queryEntityRefs.map((r) => r.toLowerCase()));\n    working = applyFilter(working, filteredBy, FILTER_LABELS.entityRefMismatch, (c) => {\n      const ref = c.memory.frontmatter.entityRef;\n      if (!ref) return true;\n      return normRefs.has(ref.toLowerCase());\n    });\n  }\n\n  if (working.length === 0) {\n    return {\n      eligible: false,\n      reason: \"no-eligible-candidates\",\n      narrative: \"no candidates survived eligibility filters\",\n      filteredBy,\n    };\n  }\n\n  const scored: ScoredCandidate[] = working.map((candidate) => {\n    const searchable = `${candidate.memory.frontmatter.tags?.join(\" \") ?? \"\"} ${candidate.memory.content}`.trim();\n    const searchableTokens = normalizeRecallTokenSet(searchable);\n    const requiredSearchableTokens = normalizeRecallTokenSet(searchable, [], { minTokenLength: 1 });\n    const requiredPhrases = requiredCjkPhraseTokens(query);\n    const requiredMixedTokens = requiredMixedScriptTokens(query);\n    const requiredUnicodeTokens = requiredSegmentableUnicodeTokens(queryTokens);\n    const hasRequiredPhrase =\n      requiredPhrases.length === 0 || requiredPhrases.every((token) => searchableTokens.has(token));\n    const hasRequiredMixedTokens =\n      requiredMixedTokens.length === 0 || requiredMixedTokens.every((token) => requiredSearchableTokens.has(token));\n    const hasRequiredUnicodeTokens =\n      requiredUnicodeTokens.length === 0 || requiredUnicodeTokens.every((token) => searchableTokens.has(token));\n    const requiredTokenMismatch = !hasRequiredPhrase || !hasRequiredMixedTokens || !hasRequiredUnicodeTokens;\n    const matches = requiredTokenMismatch ? 0 : countTokenOverlap(queryTokens, searchableTokens);\n    return { candidate, tokenOverlap: matches / queryTokens.size, requiredTokenMismatch };\n  });\n\n  const overlapSurvivors = scored.filter((s) => !s.requiredTokenMismatch && s.tokenOverlap >= config.tokenOverlapFloor);\n  if (overlapSurvivors.length < scored.length) {\n    filteredBy.push(FILTER_LABELS.belowTokenOverlapFloor);\n  }\n\n  if (overlapSurvivors.length === 0) {\n    return {\n      eligible: false,\n      reason: \"below-token-overlap-floor\",\n      narrative: `no candidate met token-overlap floor ${config.tokenOverlapFloor}`,\n      filteredBy,\n    };\n  }\n\n  overlapSurvivors.sort(compareScored);\n\n  if (overlapSurvivors.length >= 2) {\n    const topScore = scoreFor(overlapSurvivors[0]);\n    const secondScore = scoreFor(overlapSurvivors[1]);\n    if (topScore - secondScore < config.ambiguityMargin) {\n      return {\n        eligible: false,\n        reason: \"ambiguous\",\n        narrative: `top two candidates within ambiguityMargin ${config.ambiguityMargin}`,\n        filteredBy,\n      };\n    }\n  }\n\n  const winner = overlapSurvivors[0];\n  const bucket = winner.candidate.taxonomyBucket ?? \"unknown\";\n  return {\n    eligible: true,\n    reason: \"eligible\",\n    winner: winner.candidate,\n    tokenOverlap: winner.tokenOverlap,\n    narrative: `trusted ${bucket}, unambiguous, token-overlap ${winner.tokenOverlap.toFixed(2)}`,\n    filteredBy,\n  };\n}\n\nfunction applyFilter(\n  working: DirectAnswerCandidate[],\n  filteredBy: string[],\n  label: string,\n  keep: (c: DirectAnswerCandidate) => boolean\n): DirectAnswerCandidate[] {\n  const before = working.length;\n  const next = working.filter(keep);\n  if (next.length < before) filteredBy.push(label);\n  return next;\n}\n\nfunction scoreFor(s: ScoredCandidate): number {\n  return s.candidate.matchScore ?? s.tokenOverlap;\n}\n\nfunction compareScored(a: ScoredCandidate, b: ScoredCandidate): number {\n  const diff = scoreFor(b) - scoreFor(a);\n  if (diff !== 0) return diff;\n  // Stable secondary key on path so the comparator returns 0 only for equal\n  // entries (CLAUDE.md rule 19).\n  return a.candidate.memory.path.localeCompare(b.candidate.memory.path);\n}\n"],"mappings":"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","names":["segment"]}

package/dist/{chunk-UW74LP76.js → chunk-Q35XGIEM.js}

@@ -19,7 +19,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   compareEntityTimestamps
-} from "./chunk-OF6KQJ35.js";
+} from "./chunk-JWPG65LH.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -929,4 +929,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-UW74LP76.js.map
+//# sourceMappingURL=chunk-Q35XGIEM.js.map

package/dist/{chunk-XPRJSHNI.js → chunk-QJ622LTI.js}

@@ -2,6 +2,9 @@ import {
   isTemporalQuery,
   recencyWindowBoundsFromPrompt
 } from "./chunk-ZOKZIR5K.js";
+import {
+  normalizeRecallTokens
+} from "./chunk-YCVB7X56.js";
 import {
   isAbortError
 } from "./chunk-BTTPKDIL.js";
@@ -23,7 +26,7 @@ var PARALLEL_AGENT_WEIGHTS = {
 function shouldRunAgent(agent, query, knownEntityCount) {
   switch (agent) {
     case "direct":
-      return knownEntityCount > 0 || /\b\w{2,}/.test(query);
+      return knownEntityCount > 0 || /[\p{L}\p{N}]{2,}/u.test(query);
     case "temporal":
       return isTemporalQuery(query);
     case "contextual":
@@ -33,7 +36,7 @@ function shouldRunAgent(agent, query, knownEntityCount) {
   }
 }
 function tokenize(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter((t) => t.length >= 2);
+  return normalizeRecallTokens(value).filter((t) => t.length >= 2);
 }
 function overlapScore(queryTokens, candidateTokens) {
   if (queryTokens.length === 0 || candidateTokens.length === 0) return 0;
@@ -427,4 +430,4 @@ export {
   augmentWithDirectAndTemporal,
   parallelRetrieval
 };
-//# sourceMappingURL=chunk-XPRJSHNI.js.map
+//# sourceMappingURL=chunk-QJ622LTI.js.map

package/dist/chunk-QJ622LTI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/retrieval-agents.ts"],"sourcesContent":["/**\n * Parallel Specialized Retrieval (v9.1 — ASMR-inspired)\n *\n * Replaces single-pass hybrid search with three parallel specialized agents:\n *\n *   1. DirectFactAgent  — entity-first lookup via entity filename index (<5ms)\n *   2. ContextualAgent  — existing hybridSearch (same cost as current single-pass)\n *   3. TemporalAgent    — temporal index prefilter + recency scoring (<10ms)\n *\n * All agents run via Promise.all(), so total latency = max(agents), not sum.\n * No new LLM inference is introduced — agents reuse existing search primitives.\n *\n * Graceful degradation: any agent error/timeout does not block the others.\n *\n * References:\n *   - Supermemory ASMR: https://blog.supermemory.ai/...\n *   - Spec: docs/ideas/parallel-specialized-retrieval.md\n */\n\nimport path from \"node:path\";\nimport { lstat, readdir, readFile, realpath, stat } from \"node:fs/promises\";\nimport { log } from \"./logger.js\";\nimport type { QmdSearchResult } from \"./types.js\";\nimport type { QmdClient } from \"./qmd.js\";\nimport { isTemporalQuery, recencyWindowBoundsFromPrompt } from \"./temporal-index.js\";\nimport { isAbortError } from \"./abort-error.js\";\nimport { normalizeRecallTokens } from \"./recall-tokenization.js\";\n\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\nexport type SearchAgentSource = \"direct\" | \"contextual\" | \"temporal\";\n\nexport interface ParallelSearchResult extends QmdSearchResult {\n  /** Which retrieval agent produced this result. */\n  agentSource: SearchAgentSource;\n}\n\n/** Source-based weights applied during merge. Higher = higher confidence/precision. */\nexport const PARALLEL_AGENT_WEIGHTS: Record<SearchAgentSource, number> = {\n  direct: 1.0, // entity-first: high precision\n  temporal: 0.85, // recency-boosted: relevant but broader\n  contextual: 0.7, // semantic: broadest, lower precision\n};\n\n// ─── Query classification ────────────────────────────────────────────────────\n\n/**\n * Decide whether a given agent should run for this query.\n * Agent 1 (direct) is the only one that may be skipped — when the query\n * contains no proper-noun-like tokens, entity lookups will return nothing.\n * Agents 2 (contextual) and 3 (temporal) always run.\n */\nexport function shouldRunAgent(\n  agent: SearchAgentSource,\n  query: string,\n  knownEntityCount: number,\n): boolean {\n  switch (agent) {\n    case \"direct\":\n      // Skip only if the query has no letter/number tokens. `\\w` and `\\b` are\n      // ASCII-only, so CJK entity names would never start the direct agent.\n      return knownEntityCount > 0 || /[\\p{L}\\p{N}]{2,}/u.test(query);\n    case \"temporal\":\n      // Only run temporal agent when the query actually asks about a time window.\n      // Running it for every query injects recency bias into semantic searches.\n      return isTemporalQuery(query);\n    case \"contextual\":\n      return true;\n    default:\n      return true;\n  }\n}\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\nfunction tokenize(value: string): string[] {\n  return normalizeRecallTokens(value).filter((t) => t.length >= 2);\n}\n\nfunction overlapScore(queryTokens: string[], candidateTokens: string[]): number {\n  if (queryTokens.length === 0 || candidateTokens.length === 0) return 0;\n  const candidateSet = new Set(candidateTokens);\n  const hits = queryTokens.filter((t) => candidateSet.has(t)).length;\n  return hits / Math.max(queryTokens.length, candidateTokens.length);\n}\n\nasync function resolveContainedRegularFile(\n  memoryDir: string,\n  candidatePath: string,\n  canonicalRoot?: string,\n): Promise<string | null> {\n  try {\n    const root = canonicalRoot ?? await realpath(memoryDir);\n    const absolute = path.isAbsolute(candidatePath)\n      ? path.resolve(candidatePath)\n      : path.resolve(memoryDir, candidatePath);\n    const entryStat = await lstat(absolute);\n    if (entryStat.isSymbolicLink()) return null;\n    const fileStat = await stat(absolute);\n    if (!fileStat.isFile()) return null;\n    const canonical = await realpath(absolute);\n    if (canonical !== root && !canonical.startsWith(root + path.sep)) return null;\n    return absolute;\n  } catch {\n    return null;\n  }\n}\n\n// ─── Agent 1: Direct Facts ───────────────────────────────────────────────────\n\n/**\n * Direct Facts Agent — entity-first retrieval.\n *\n * Reads entity filenames from the entities directory and scores them by\n * keyword overlap with the query. Returns matching entity file paths as\n * QmdSearchResult[]. Zero LLM inference; pure file I/O.\n *\n * Cost: readdir on entities/ + filename scoring. Typically <5ms.\n *\n */\n// Agents scan one namespace storage dir and return absolute paths. Contextual\n// fanout hits are also absolute (globally-unique identity), so we keep the\n// agent path absolute and only stamp the owning namespace here — that carries\n// the namespace through merge/tracking without re-deriving it (#2020). No-op\n// without a resolver.\nfunction namespaceRelativeResult(\n  result: ParallelSearchResult,\n  _memoryDir: string,\n  namespaceFromPath?: (p: string) => string,\n): ParallelSearchResult {\n  if (!namespaceFromPath || !result.path || result.namespace) return result;\n  return { ...result, namespace: namespaceFromPath(result.path) };\n}\n\nexport async function runDirectAgent(\n  query: string,\n  memoryDir: string,\n  maxResults = 10,\n  namespaceFromPath?: (p: string) => string,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const canonicalRoot = await realpath(memoryDir);\n    const entitiesDir = path.join(memoryDir, \"entities\");\n    let entries: string[];\n    try {\n      entries = await readdir(entitiesDir);\n    } catch {\n      return []; // entities dir missing or unreadable — not an error\n    }\n\n    const queryTokens = tokenize(query);\n    if (queryTokens.length === 0) return [];\n\n    const results: ParallelSearchResult[] = [];\n    for (const entry of entries) {\n      if (!entry.endsWith(\".md\")) continue;\n\n      // Filename tokens: split on hyphens (normalizeEntityName uses hyphens)\n      const nameWithoutExt = entry.slice(0, -3);\n      const entityTokens = nameWithoutExt.split(\"-\").filter((t) => t.length >= 2).map((t) => t.toLowerCase());\n\n      const score = overlapScore(queryTokens, entityTokens);\n      if (score <= 0) continue;\n\n      const fullPath = path.join(entitiesDir, entry);\n      const safePath = await resolveContainedRegularFile(memoryDir, fullPath, canonicalRoot);\n      if (!safePath) continue;\n\n      results.push(\n        namespaceRelativeResult(\n          {\n            docid: nameWithoutExt,\n            path: safePath,\n            snippet: \"\", // populated by augmentWithDirectAndTemporal after merge\n            score,\n            transport: \"scoped_prefilter\",\n            agentSource: \"direct\",\n          },\n          memoryDir,\n          namespaceFromPath,\n        ),\n      );\n    }\n\n    return results\n      .sort((a, b) => b.score - a.score)\n      .slice(0, maxResults);\n  } catch (err) {\n    log.debug(`DirectFactAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Agent 3: Temporal ───────────────────────────────────────────────────────\n\n/**\n * Temporal Agent — recency-focused retrieval.\n *\n * Uses the temporal index (index_time.json) to find memories from the\n * recent time window derived from the query (default: last 7 days).\n * Combines recency decay with query-filename token overlap so results stay\n * relevant to the query content, not just recency. Zero LLM inference; File I/O + math.\n *\n * Cost: read index_time.json + date range scan. Typically <10ms.\n */\nexport async function runTemporalAgent(\n  query: string,\n  memoryDir: string,\n  maxResults = 20,\n  /** Optional candidate set from query-aware prefilter. Applied BEFORE the top-K cap so\n   * in-scope entries are not displaced by newer out-of-scope entries. */\n  candidatePaths?: Set<string> | null,\n  namespaceFromPath?: (p: string) => string,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const canonicalRoot = await realpath(memoryDir);\n    // Read index_time.json once — used for both date-range filtering and recency scoring.\n    let dateIndex: Record<string, string[]> = {};\n    try {\n      const indexPath = path.join(memoryDir, \"state\", \"index_time.json\");\n      const raw = await readFile(indexPath, \"utf-8\");\n      const parsed = JSON.parse(raw) as { dates?: Record<string, string[]> };\n      dateIndex = parsed.dates ?? {};\n    } catch {\n      return []; // Index missing or unreadable — nothing to return\n    }\n\n    // Derive both window edges from the same function so fromDate/toDate always use\n    // consistent pattern-matching and priority ordering.\n    const { fromDate, toDate } = recencyWindowBoundsFromPrompt(query);\n\n    // Build path → date map, filtering to the recency window in one pass.\n    // Apply candidatePaths here (before scoring + top-K) so in-scope entries are\n    // not displaced by newer out-of-scope entries at the slice boundary.\n    const pathToDate = new Map<string, string>();\n    for (const [date, datePaths] of Object.entries(dateIndex)) {\n      // toDate is an exclusive upper bound (the first day NOT included in the window).\n      // e.g. \"3 days ago\" → fromDate=\"2026-03-12\", toDate=\"2026-03-13\" → only includes 2026-03-12.\n      if (date >= fromDate && date < toDate) {\n        for (const p of datePaths) {\n          // Skip paths excluded by the query-aware prefilter scope\n          if (candidatePaths && !candidatePaths.has(p)) continue;\n          if (!pathToDate.has(p)) pathToDate.set(p, date);\n        }\n      }\n    }\n\n    if (pathToDate.size === 0) return [];\n\n    const todayMs = Date.now();\n\n    // Extract non-temporal topic tokens for tag-based relevance boost.\n    // Purely temporal words (dates, relative time) and common stopwords are stripped\n    // so the signal reflects the subject the user is asking about (e.g. \"auth\" in\n    // \"what changed in auth last week\"), not the time window itself.\n    const TEMPORAL_STOPWORDS = new Set([\n      \"today\", \"yesterday\", \"this\", \"last\", \"week\", \"month\", \"year\",\n      \"morning\", \"night\", \"now\", \"earlier\", \"since\", \"after\", \"before\",\n      \"ago\", \"hours\", \"days\", \"weeks\", \"months\",\n      \"january\", \"february\", \"march\", \"april\", \"may\", \"june\",\n      \"july\", \"august\", \"september\", \"october\", \"november\", \"december\",\n      \"monday\", \"tuesday\", \"wednesday\", \"thursday\", \"friday\", \"saturday\", \"sunday\",\n      \"what\", \"when\", \"where\", \"who\", \"why\", \"how\", \"the\", \"a\", \"an\",\n      \"and\", \"or\", \"in\", \"on\", \"at\", \"to\", \"of\", \"for\", \"with\", \"by\",\n      \"from\", \"changed\", \"happened\", \"was\", \"were\", \"is\", \"are\", \"did\",\n      \"about\", \"that\", \"have\", \"had\", \"has\", \"been\", \"any\", \"all\",\n    ]);\n    const topicTokens = tokenize(query).filter((t) => !TEMPORAL_STOPWORDS.has(t));\n\n    // Load tag index for topical scoring, in parallel with existence checks.\n    // Fail-open: if the tag index is unavailable, topicBoost = 0 and scores\n    // degrade gracefully to recency-only ordering (existing behaviour).\n    const entries = [...pathToDate.entries()];\n    const tagIndexPromise: Promise<Map<string, string[]>> = topicTokens.length > 0\n      ? readFile(path.join(memoryDir, \"state\", \"index_tags.json\"), \"utf-8\")\n          .then((raw) => {\n            const parsed = JSON.parse(raw) as { tags?: Record<string, { paths?: string[] } | string[]> };\n            const result = new Map<string, string[]>();\n            for (const [tag, node] of Object.entries(parsed.tags ?? {})) {\n              const tagPaths = Array.isArray(node) ? node : (node.paths ?? []);\n              for (const tp of tagPaths) {\n                const existing = result.get(tp);\n                if (existing) existing.push(tag);\n                else result.set(tp, [tag]);\n              }\n            }\n            return result;\n          })\n          .catch(() => new Map<string, string[]>())\n      : Promise.resolve(new Map<string, string[]>());\n\n    // Parallel: existence checks + tag index read.\n    const [safePathResults, pathToTags] = await Promise.all([\n      Promise.all(entries.map(([p]) => resolveContainedRegularFile(memoryDir, p, canonicalRoot))),\n      tagIndexPromise,\n    ]);\n\n    const results: ParallelSearchResult[] = [];\n\n    for (let i = 0; i < entries.length; i++) {\n      const [p, dateStr] = entries[i];\n      const safePath = safePathResults[i];\n      if (!safePath) continue; // skip stale or out-of-root index entry\n      const ageMs = todayMs - new Date(dateStr).getTime();\n      const ageDays = ageMs / 86_400_000;\n      // Exponential recency decay with half-life of ~30 days.\n      // score ≈ 1.0 at day 0, ≈ 0.79 at 7 days, ≈ 0.36 at 30 days, ≈ 0.13 at 60 days.\n      const recencyScore = Math.exp(-ageDays / 30);\n\n      // Topical boost: fraction of non-temporal query tokens matched by this file's tags.\n      // Adds up to +30% on recency score for a perfect tag match; zero when query is\n      // purely temporal (no topic tokens) or the tag index doesn't cover the file.\n      let topicBoost = 0;\n      if (topicTokens.length > 0) {\n        const tags = pathToTags.get(p) ?? pathToTags.get(safePath);\n        if (tags && tags.length > 0) {\n          const tagSet = new Set(tags.flatMap((t) => tokenize(t)));\n          const hits = topicTokens.filter((t) => tagSet.has(t)).length;\n          topicBoost = hits / topicTokens.length;\n        }\n      }\n      const score = recencyScore * (1 + topicBoost * 0.3);\n\n      const baseName = path.basename(safePath, \".md\");\n\n      results.push(\n        namespaceRelativeResult(\n          {\n            docid: baseName,\n            path: safePath,\n            snippet: \"\", // populated by augmentWithDirectAndTemporal after merge\n            score,\n            transport: \"scoped_prefilter\",\n            agentSource: \"temporal\",\n          },\n          memoryDir,\n          namespaceFromPath,\n        ),\n      );\n    }\n\n    return results\n      .sort((a, b) => b.score - a.score)\n      .slice(0, maxResults);\n  } catch (err) {\n    log.debug(`TemporalAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Agent 2: Contextual ─────────────────────────────────────────────────────\n\n/**\n * Contextual Agent — broad semantic/hybrid search.\n *\n * Delegates to the existing hybridSearch (BM25 + vector). Same cost as the\n * current single-pass retrieval — this agent introduces no additional LLM calls.\n */\nexport async function runContextualAgent(\n  query: string,\n  qmd: QmdClient,\n  collection: string | undefined,\n  maxResults: number,\n  signal?: AbortSignal,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const results = await qmd.hybridSearch(\n      query,\n      collection,\n      maxResults,\n      signal ? { signal } : undefined,\n    );\n    return results.map((r: QmdSearchResult) => ({ ...r, agentSource: \"contextual\" as const }));\n  } catch (err) {\n    if (isAbortError(err)) throw err;\n    log.debug(`ContextualAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Merge helper ─────────────────────────────────────────────────────────────\n\n/**\n * Merge results from multiple agents into a single deduplicated, weighted list.\n * Deduplicates by (namespace, path). Contextual results carry a `namespace`\n * (from the namespace-fanout search); direct/temporal results do not. When a\n * `resolveNamespace` resolver is supplied, the missing namespace is derived from\n * the result path the same canonical way the contextual side derives it\n * (`result.namespace ?? resolveNamespace(result.path)`), so a direct/temporal hit\n * and a contextual hit for the same (namespace, path) collapse to ONE merge key\n * instead of being injected and access-counted twice. Preserves snippets: if a\n * higher-scoring result lacks a snippet, the existing snippet from a lower-scoring\n * source is retained.\n */\nfunction mergeAgentResults(\n  allResults: ParallelSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxResults: number,\n  resolveNamespace?: (path: string) => string,\n): QmdSearchResult[] {\n  const merged = new Map<string, QmdSearchResult>();\n  for (const result of allResults) {\n    const namespace =\n      result.namespace ?? (resolveNamespace && result.path ? resolveNamespace(result.path) : undefined);\n    const key = `${namespace ?? \"\"}\\0${result.path || result.docid}`;\n    const weightedScore = result.score * weights[result.agentSource];\n    const existing = merged.get(key);\n    if (!existing || weightedScore > existing.score) {\n      merged.set(key, {\n        docid: result.docid,\n        path: result.path,\n        namespace,\n        // Preserve any snippet from the existing entry when the new one has none\n        snippet: result.snippet || existing?.snippet || \"\",\n        score: weightedScore,\n        transport: \"hybrid\",\n      });\n    }\n  }\n  return [...merged.values()]\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults);\n}\n\n/**\n * For merged results that have an empty snippet, attempt to read the first\n * 200 characters of the file as a fallback preview. Bounded to MAX_SNIPPET_READS\n * to cap I/O when many specialized-agent results are present.\n */\nconst SNIPPET_PREVIEW_CHARS = 200;\nconst MAX_SNIPPET_READS = 8;\n\n/** Strip YAML frontmatter (---...---) and return the document body. */\nfunction stripFrontmatter(raw: string): string {\n  if (!raw.startsWith(\"---\")) return raw;\n  const end = raw.indexOf(\"\\n---\", 3);\n  if (end === -1) return raw;\n  // Skip the closing \"---\" line and any leading blank lines\n  return raw.slice(end + 4).replace(/^\\n+/, \"\");\n}\n\nasync function populateEmptySnippets(results: QmdSearchResult[], memoryDir?: string): Promise<QmdSearchResult[]> {\n  const needsSnippet = results.filter((r) => !r.snippet && r.path);\n  if (needsSnippet.length === 0) return results;\n  const canonicalRoot = memoryDir ? await realpath(memoryDir).catch(() => null) : null;\n\n  const toRead = needsSnippet.slice(0, MAX_SNIPPET_READS);\n  const snippetMap = new Map<string, string>();\n\n  await Promise.all(\n    toRead.map(async (r) => {\n      try {\n        const safePath = canonicalRoot && r.path\n          ? await resolveContainedRegularFile(memoryDir!, r.path, canonicalRoot)\n          : null;\n        if (!safePath) return;\n        const raw = await readFile(safePath, \"utf-8\");\n        // Memory files start with YAML frontmatter — skip it so the snippet\n        // contains actual memory content, not metadata fields.\n        const body = stripFrontmatter(raw);\n        const preview = body.slice(0, SNIPPET_PREVIEW_CHARS).replace(/\\s+/g, \" \").trim();\n        if (preview) snippetMap.set(r.path, preview);\n      } catch {\n        // File unreadable — leave snippet empty\n      }\n    }),\n  );\n\n  if (snippetMap.size === 0) return results;\n  return results.map((r) => (r.path && snippetMap.has(r.path) ? { ...r, snippet: snippetMap.get(r.path)! } : r));\n}\n\n/**\n * Merge pre-computed direct and temporal agent results with contextual results.\n *\n * This is the merge half of augmentWithDirectAndTemporal. Expose it separately so\n * callers that started agents concurrently with the contextual search (for true\n * parallel latency) can merge after all three complete, without re-running agents.\n *\n * Handles the same cases as augmentWithDirectAndTemporal:\n * - Returns contextual unchanged (no reweighting) when both agents return nothing\n * - Applies maxResults cap in all paths\n * - Populates snippets for results discovered only by specialized agents\n */\nexport async function mergeWithAgentResults(\n  contextualResults: QmdSearchResult[],\n  directResults: ParallelSearchResult[],\n  temporalResults: ParallelSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxResults: number,\n  memoryDir?: string,\n  /** Optional namespace resolver. Direct/temporal results lack a namespace under\n   * namespace fanout; deriving it from the path lets them collapse onto the same\n   * merge key as the contextual result for the same (namespace, path). */\n  resolveNamespace?: (path: string) => string,\n): Promise<QmdSearchResult[]> {\n  if (directResults.length === 0 && temporalResults.length === 0) {\n    return contextualResults.slice(0, maxResults);\n  }\n\n  const contextualTagged: ParallelSearchResult[] = contextualResults.map((r) => ({\n    ...r,\n    agentSource: \"contextual\" as const,\n  }));\n\n  const merged = mergeAgentResults(\n    [...contextualTagged, ...directResults, ...temporalResults],\n    weights,\n    maxResults,\n    resolveNamespace,\n  );\n  return populateEmptySnippets(merged, memoryDir);\n}\n\n// ─── Augmentation helper (used by tests; orchestrator uses inline logic) ─────\n//\n// NOTE: This function passes the same `memoryDir` to both direct and temporal\n// agents. The orchestrator's inline implementation differs: it passes a\n// namespace-specific storage dir to runDirectAgent and the shared root to\n// runTemporalAgent. augmentWithDirectAndTemporal is intentionally simpler\n// (single-dir assumption) and is exercised by unit tests where both agents\n// operate on the same temporary directory.\n\n/**\n * Augment a set of contextual (hybridSearch) results with direct and temporal\n * agent results, returning a merged, deduplicated list.\n *\n * **Test helper** — production recall uses the inline orchestrator path which\n * passes namespace-specific directories to each agent. This function uses a\n * simplified single-directory contract suitable for unit tests.\n *\n * Direct and temporal agents run in parallel, then all three are merged with\n * configurable weights.\n *\n * Contextual weight is always applied to `contextualResults` so scoring is\n * consistent regardless of whether direct/temporal agents return anything.\n *\n * Snippets: snippets from contextual results are preserved during merge. For\n * results discovered only by direct/temporal agents (no contextual match),\n * the first ~200 chars of the file are read as a fallback preview so downstream\n * formatters and rerankers have content to work with, not just a path.\n */\nexport async function augmentWithDirectAndTemporal(\n  query: string,\n  memoryDir: string,\n  contextualResults: QmdSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxPerAgent: number,\n  maxResults: number,\n  /** Optional candidate set from query-aware prefilter (time/tag scoped). Agents' results are\n   * filtered to this set when provided so recall stays within the operator-specified scope. */\n  candidatePaths?: Set<string> | null,\n  /** Optional namespace resolver so direct/temporal results collapse onto the same\n   * (namespace, path) merge key as their contextual counterpart. */\n  resolveNamespace?: (path: string) => string,\n): Promise<QmdSearchResult[]> {\n  // maxPerAgent=0 is a hard disable: skip agents entirely and return contextual unchanged\n  if (maxPerAgent === 0) return contextualResults;\n\n  const knownEntityCount = (query.match(/\\b[A-Z][a-z]{1,}/g) ?? []).length;\n  const runDirect = shouldRunAgent(\"direct\", query, knownEntityCount);\n  const runTemporal = shouldRunAgent(\"temporal\", query, knownEntityCount);\n\n  const startMs = Date.now();\n  const [directResults, temporalResults] = await Promise.all([\n    runDirect\n      ? runDirectAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`augmentWithDirectAndTemporal: DirectAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runTemporal\n      // Pass candidatePaths so scope-filtering happens before the top-K cap inside runTemporalAgent,\n      // preventing out-of-scope newer entries from displacing in-scope ones at the slice boundary.\n      ? runTemporalAgent(query, memoryDir, maxPerAgent, candidatePaths).catch((err) => {\n        log.debug(`augmentWithDirectAndTemporal: TemporalAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n  ]);\n  const durationMs = Date.now() - startMs;\n\n  // Direct agent results (entities/) intentionally bypass candidatePaths.\n  //\n  // Why: candidatePaths is built from temporal + tag indexes, which never include\n  // entity files (entities/*.md). Applying the filter here would silently drop ALL\n  // direct-agent results for any scoped query, making the direct agent a no-op.\n  // Entity files are identified by filename matching (query tokens vs. entity name),\n  // so they are already query-scoped independently of the time/tag prefilter.\n  // Temporal results are scoped inside runTemporalAgent() before the top-K cap.\n  const scopedDirect = directResults;\n\n  // Tag contextual results with their source so they can participate in weighted merge.\n  // We do NOT cap contextual here: contextualResults comes from fetchQmdMemoryResultsWithArtifactTopUp\n  // which intentionally over-fetches so downstream phases (graph expansion, lifecycle filtering,\n  // reranking) can drop candidates. Capping before the merge would remove that headroom.\n  const contextualTagged: ParallelSearchResult[] = contextualResults.map((r) => ({\n    ...r,\n    agentSource: \"contextual\" as const,\n  }));\n\n  log.debug(\n    `augmentWithDirectAndTemporal: direct=${scopedDirect.length} temporal=${temporalResults.length} contextual=${contextualTagged.length} agentMs=${durationMs}ms`,\n  );\n\n  // If no specialized agents contributed anything (e.g. fresh setup without entities/ or temporal\n  // index), skip reweighting entirely — applying the contextual weight penalty with zero benefit\n  // would silently reduce every result score by ~30% compared to the non-augmented path.\n  if (scopedDirect.length === 0 && temporalResults.length === 0) {\n    return (contextualResults as QmdSearchResult[]).slice(0, maxResults);\n  }\n\n  // Merge all three; contextual first so its snippets are preserved when a higher-scoring\n  // direct/temporal result overrides the same path (see mergeAgentResults snippet logic).\n  // Note: maxPerAgent=0 is handled by the early-return guard above; we never reach here with 0.\n  const merged = mergeAgentResults(\n    [...contextualTagged, ...scopedDirect, ...temporalResults],\n    weights,\n    maxResults,\n    resolveNamespace,\n  );\n\n  // Populate snippets for results discovered only by direct/temporal (no contextual preview)\n  return populateEmptySnippets(merged, memoryDir);\n}\n\n// ─── Orchestrator ─────────────────────────────────────────────────────────────\n\nexport interface ParallelRetrievalOptions {\n  collection?: string;\n  maxResults?: number;\n  signal?: AbortSignal;\n  /** If true, skip the contextual agent (hybridSearch is already running externally). */\n  skipContextual?: boolean;\n  /** Max results per agent (capped before merge). */\n  maxResultsPerAgent?: number;\n  /** Override default agent weights. Falls back to PARALLEL_AGENT_WEIGHTS when absent. */\n  agentWeights?: Record<SearchAgentSource, number>;\n  /** Optional namespace resolver so direct/temporal results collapse onto the same\n   * (namespace, path) merge key as the contextual result for the same path. */\n  resolveNamespace?: (path: string) => string;\n}\n\n/**\n * Run parallel specialized retrieval agents and merge results.\n *\n * When `skipContextual` is true, only the direct and temporal agents run.\n * This is the intended usage inside the orchestrator, where hybridSearch\n * already runs as the primary search — we augment with the cheap extra agents.\n *\n * Total latency = max(agent_latencies), not sum.\n * Agent errors are isolated — others still return results.\n */\nexport async function parallelRetrieval(\n  query: string,\n  qmd: QmdClient,\n  memoryDir: string,\n  options: ParallelRetrievalOptions = {},\n): Promise<QmdSearchResult[]> {\n  const maxResults = options.maxResults ?? 20;\n  const maxPerAgent = options.maxResultsPerAgent ?? maxResults;\n  const startMs = Date.now();\n\n  // Rough entity detection: count proper-noun-like tokens in query\n  const knownEntityCount = (query.match(/\\b[A-Z][a-z]{1,}/g) ?? []).length;\n\n  const runDirect = shouldRunAgent(\"direct\", query, knownEntityCount);\n  const runTemporal = shouldRunAgent(\"temporal\", query, knownEntityCount);\n  const runContextual = !options.skipContextual && shouldRunAgent(\"contextual\", query, knownEntityCount);\n\n  const [directResults, temporalResults, contextualResults] = await Promise.all([\n    runDirect\n      ? runDirectAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`parallelRetrieval: DirectAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runTemporal\n      ? runTemporalAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`parallelRetrieval: TemporalAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runContextual\n      ? runContextualAgent(query, qmd, options.collection, maxPerAgent, options.signal).catch((err) => {\n        if (isAbortError(err)) throw err;\n        log.debug(`parallelRetrieval: ContextualAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n  ]);\n\n  const durationMs = Date.now() - startMs;\n  log.debug(\n    `parallelRetrieval: direct=${directResults.length} temporal=${temporalResults.length} contextual=${contextualResults.length} durationMs=${durationMs}ms`,\n  );\n\n  // Contextual results go first so their snippets are preserved when a higher-scoring\n  // direct/temporal result overrides the same path in mergeAgentResults.\n  const merged = mergeAgentResults(\n    [...contextualResults, ...directResults, ...temporalResults],\n    options.agentWeights ?? PARALLEL_AGENT_WEIGHTS,\n    maxResults,\n    options.resolveNamespace,\n  );\n  return populateEmptySnippets(merged, memoryDir);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-FNYIMSKI.js → chunk-QSIQVC32.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-OF6KQJ35.js";
+} from "./chunk-JWPG65LH.js";
 import {
   keyring_exports,
   secureStoreDir
@@ -412,4 +412,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-FNYIMSKI.js.map
+//# sourceMappingURL=chunk-QSIQVC32.js.map

package/dist/{chunk-EJYAE2U7.js → chunk-R74NCKEY.js}

@@ -9,14 +9,14 @@ import {
 } from "./chunk-666A3MOW.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-USKANB65.js";
+} from "./chunk-I6OQCT3Y.js";
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-S52C2DEM.js";
+} from "./chunk-5W5N7XJZ.js";
 import {
   rebuildMemoryProjection
-} from "./chunk-J5AFG5JN.js";
+} from "./chunk-EJLTNPRY.js";
 import {
   activityDayWindow,
   activityDigestPath,
@@ -1719,4 +1719,4 @@ export {
   ActivitySyncScheduler,
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-EJYAE2U7.js.map
+//# sourceMappingURL=chunk-R74NCKEY.js.map

package/dist/{chunk-KP36WQBJ.js → chunk-RYGJGXL6.js}

@@ -3,7 +3,7 @@ import {
   getOperation,
   operationRequiresAuthorizedNamespace,
   operationUsesPrincipalNamespace
-} from "./chunk-7CJO52ET.js";
+} from "./chunk-JJ7JW62R.js";
 import {
   assertOperationAuthorizationAllowed
 } from "./chunk-MZWSOLMT.js";
@@ -60,4 +60,4 @@ export {
   authorizationProbeNamespaces,
   authorizationProbeRequiresPrincipalNamespace
 };
-//# sourceMappingURL=chunk-KP36WQBJ.js.map
+//# sourceMappingURL=chunk-RYGJGXL6.js.map

package/dist/{chunk-4OW2T32G.js → chunk-SQ3EGGII.js}

@@ -1,7 +1,7 @@
 import {
   BUILTIN_CONNECTORS,
   loadRegistry
-} from "./chunk-ANMIOQPU.js";
+} from "./chunk-4XN35YQD.js";
 
 // src/connectors/label.ts
 var CONNECTOR_LABEL_MAX_LENGTH = 64;
@@ -25,4 +25,4 @@ export {
   CONNECTOR_LABEL_MAX_LENGTH,
   knownConnectorIds
 };
-//# sourceMappingURL=chunk-4OW2T32G.js.map
+//# sourceMappingURL=chunk-SQ3EGGII.js.map

package/dist/{chunk-FU7OICXE.js → chunk-TRPX6F2G.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-V7IZKJI3.js";
 import {
   AdapterRegistry
-} from "./chunk-JBPKEARU.js";
+} from "./chunk-2QSZNTDO.js";
 import {
   WriteRateLimiter
 } from "./chunk-TB6CBZ5V.js";
@@ -12,10 +12,10 @@ import {
 } from "./chunk-3HSRWJTC.js";
 import {
   handleSupportPassportOwnerHttp
-} from "./chunk-AUIAHNO7.js";
+} from "./chunk-4NMVX5U7.js";
 import {
   buildSupportPassportPublicRequestHandler
-} from "./chunk-S4MF77NV.js";
+} from "./chunk-XZPSBGHA.js";
 import {
   nonEmptyQueryParam,
   optionalQueryString,
@@ -30,13 +30,13 @@ import {
   processChatMessage,
   sessionBelongsToPrincipal,
   subscribeChatTranscript
-} from "./chunk-5LVSFKQB.js";
+} from "./chunk-IM56VPKO.js";
 import {
   RelayMissionStoreError
-} from "./chunk-ORB56L3Y.js";
+} from "./chunk-EJQXDKYK.js";
 import {
   validateRequest
-} from "./chunk-JKW663ZN.js";
+} from "./chunk-CIAI24TQ.js";
 import {
   executeResolution,
   isValidResolutionVerb
@@ -60,15 +60,15 @@ import {
   authorizationProbeNamespaces,
   authorizationProbeRequiresPrincipalNamespace,
   probeOperationAuthorization
-} from "./chunk-KP36WQBJ.js";
+} from "./chunk-RYGJGXL6.js";
 import {
   CorrectionContractError,
   getOperation,
   resolveQueryNamespaceWritablePreflight
-} from "./chunk-7CJO52ET.js";
+} from "./chunk-JJ7JW62R.js";
 import {
   isTrustZoneName
-} from "./chunk-LJOIZPJH.js";
+} from "./chunk-5QZR2RA3.js";
 import {
   subscribeGraphEvents
 } from "./chunk-DEUNUKTD.js";
@@ -3397,4 +3397,4 @@ export {
   resolveDefaultAdminConsolePublicDir,
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-FU7OICXE.js.map
+//# sourceMappingURL=chunk-TRPX6F2G.js.map

package/dist/{chunk-7K5Q6COX.js → chunk-TVVEYCNW.js}

@@ -1,9 +1,9 @@
-import {
-  appendRecallAuditEntry
-} from "./chunk-LBLXEFWK.js";
 import {
   detectRecallAnomalies
 } from "./chunk-RFYAYKTD.js";
+import {
+  appendRecallAuditEntry
+} from "./chunk-LBLXEFWK.js";
 
 // src/access-audit.ts
 var AccessAuditAdapter = class {
@@ -62,4 +62,4 @@ var AccessAuditAdapter = class {
 export {
   AccessAuditAdapter
 };
-//# sourceMappingURL=chunk-7K5Q6COX.js.map
+//# sourceMappingURL=chunk-TVVEYCNW.js.map

package/dist/{chunk-6VX2ZZH2.js → chunk-VAMQU4W7.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-OF6KQJ35.js";
+} from "./chunk-JWPG65LH.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -956,4 +956,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-6VX2ZZH2.js.map
+//# sourceMappingURL=chunk-VAMQU4W7.js.map

package/dist/{chunk-WLITCQAC.js → chunk-VN7IIQGS.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-UYCIS6V5.js";
 import {
   StorageManager
-} from "./chunk-OF6KQJ35.js";
+} from "./chunk-JWPG65LH.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1283,4 +1283,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-WLITCQAC.js.map
+//# sourceMappingURL=chunk-VN7IIQGS.js.map

package/dist/{chunk-MMM7SDOJ.js → chunk-WDUG2CH3.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-RDFF2NAU.js";
 import {
   StorageManager
-} from "./chunk-OF6KQJ35.js";
+} from "./chunk-JWPG65LH.js";
 import {
   excludeSupportPassportPrivateMemories
 } from "./chunk-XDL5CYZN.js";
@@ -138,4 +138,4 @@ export {
   runCodexMaterialize,
   runPostConsolidationMaterialize
 };
-//# sourceMappingURL=chunk-MMM7SDOJ.js.map
+//# sourceMappingURL=chunk-WDUG2CH3.js.map

package/dist/{chunk-P2BT5ALE.js → chunk-X4MGNVOO.js}

@@ -16,7 +16,7 @@ import {
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
-} from "./chunk-DJ7HMNSL.js";
+} from "./chunk-YCVB7X56.js";
 import {
   inferMemoryStatus,
   toMemoryPathRel
@@ -296,4 +296,4 @@ async function searchHarmonicRetrieval(options) {
 export {
   searchHarmonicRetrieval
 };
-//# sourceMappingURL=chunk-P2BT5ALE.js.map
+//# sourceMappingURL=chunk-X4MGNVOO.js.map