@remnic/core 9.65.0 → 9.65.2

package/src/orchestration/recall-internal.ts

@@ -25,6 +25,7 @@ import path from "node:path";
 import { type BoxFrontmatter } from "../boxes.js";
 import { type CapabilitySet, type GraphConstructionCapabilitySet, type MemoryLifecycleCapabilitySet, type SecurityCapabilitySet, resolveCapabilities, resolveCompressionCapabilities, resolveConsolidationCapabilities, resolveConversationContextCapabilities, resolveCreationMemoryCapabilities, resolveGraphConstructionCapabilities, resolveIdentityContinuityCapabilities, resolveIndexingCapabilities, resolveMemoryLifecycleCapabilities, resolveNamespaceCapabilities, resolveObjectiveStateCapabilities, resolvePipelineProcessingCapabilities, resolvePresentationCapabilities, resolveQmdCapabilities, resolveRecallAuxiliaryCapabilities, resolveRecallEnhancementCapabilities, resolveSecurityCapabilities } from "../capabilities.js";
 import { searchCausalTrajectories } from "../causal-trajectory.js";
+import { detectLanguageHint, dominantCorpusLanguage, planCrossScript } from "../cross-lingual-recall.js";
 import { buildEntityRecallSection, entityRecentTranscriptLookbackHours, readRecentEntityTranscriptEntries } from "../entity-retrieval.js";
 import { buildEventOrderRecallSection, shouldRecallEventOrderEvidence } from "../event-order-recall.js";
 import { buildExplicitCueRecallSection } from "../explicit-cue-recall.js";
@@ -38,7 +39,7 @@ import { canReadNamespace, resolvePrincipal } from "../namespaces/principal.js";
 import { collectNativeKnowledgeChunks, formatNativeKnowledgeSection, searchNativeKnowledge } from "../native-knowledge.js";
 import { objectiveStateStoreOverrideForNamespace, searchObjectiveStateSnapshots } from "../objective-state.js";
 import { type GraphRecallRankedResult, type GraphRecallShadowComparison, mergeGraphExpandedResults } from "./graph-recall-coordinator.js";
-import { buildProcedureRecallSection } from "../procedural/procedure-recall.js";
+import { buildProcedureRecallSection, mergeProcedureInjections } from "../procedural/procedure-recall.js";
 import { canRecallToolScopedMemory } from "../tool-scoped-memory.js";
 import { buildQmdRecallCacheKey, getCachedQmdRecall, setCachedQmdRecall } from "../qmd-recall-cache.js";
 import { MEMORY_ID_PATTERN } from "../recall-handles.js";
@@ -261,34 +262,22 @@ export class RecallInternalCoordinator {
     // per-result explain data (e.g. reinforcementBoost) from the result that
     // was actually served.
     let xrayRecalledResults: QmdSearchResult[] = [];
-    // Issue #1577 — per-recall trust map (admitted + quarantined items).
-    // A LOCAL, not instance state, so concurrent recalls on the same
-    // orchestrator cannot race on it (review: shared-trust-map concurrency).
-    // Populated by applyTrustScoreRerank on whichever recall path runs;
-    // consumed by formatQmdResults (epistemic hedge), publishRecallResults
-    // (quarantine filtering on ALL paths), and the X-ray capture (trust
-    // projection + quarantined-item visibility — rule 34).
+    // Issue #1577 — per-recall trust map (admitted + quarantined). LOCAL, not
+    // instance state, so concurrent recalls cannot race on it. Consumed by
+    // formatQmdResults, publishRecallResults (quarantine filtering on ALL
+    // paths), and the X-ray capture (rule 34).
     let recallTrustByPath: Map<string, TrustStageResultItem> | null = null;
-    // Issue #1577 — sink for the cold-fallback pipeline's trust map. The cold
-    // pipeline scores internally (applyColdFallbackPipeline) and writes its
-    // per-path trust map here; each cold caller reads it back into
-    // recallTrustByPath so cold/embedding/recent paths feed the same X-ray +
-    // epistemic-rendering + publisher-quarantine consumers the hot path uses
-    // (rule 41: the feature gate applies across ALL parallel recall paths).
+    // Issue #1577 — sink for the cold pipeline's trust map: cold callers read
+    // it back into recallTrustByPath so every path feeds the same consumers
+    // (rule 41 parity).
     const trustByPathSink: { trustByPath: Map<string, TrustStageResultItem> | null } = {
       trustByPath: null,
     };
     const lcmStructuredXrayResults: RecallXrayResult[] = [];
-    // Per-branch pre-limit candidate pool size for the X-ray filter
-    // trace (issue #570 PR 1).  `recalledMemoryCount` is assigned
-    // AFTER MMR + truncation so using it alone would make the
-    // `recall-result-limit` trace report `considered == admitted`
-    // even when many candidates were dropped.  Each entry captures
-    // the pool size BEFORE truncation at that branch.  The X-ray
-    // capture block picks the pool that corresponds to the branch
-    // that actually produced the admitted results (via `recallSource`)
-    // so a pool from a branch whose candidates were killed by an
-    // earlier gate cannot leak into the `considered` count.
+    // Per-branch PRE-truncation pool size for the X-ray filter trace
+    // (issue #570 PR 1): `recalledMemoryCount` is post-truncation, so the
+    // trace would otherwise report considered == admitted. The capture block
+    // picks the branch that produced the admitted results via `recallSource`.
     const xrayBranchPoolSize: Record<
       "hot_qmd" | "hot_embedding" | "cold_fallback" | "recent_scan",
       number
@@ -298,11 +287,9 @@ export class RecallInternalCoordinator {
       cold_fallback: 0,
       recent_scan: 0,
     };
-    // Shared out-parameter sink the cold-fallback pipeline writes
-    // its pre-truncation pool size into (issue #570 PR 1).  Declared
-    // once so every call to `applyColdFallbackPipeline` (four call
-    // sites) updates the same counter; the X-ray capture block
-    // reads this as the cold-fallback pool.
+    // Sink the cold-fallback pipeline (four call sites) writes its
+    // pre-truncation pool size into (issue #570 PR 1); the X-ray capture
+    // block reads it as the cold-fallback pool.
     const xrayColdPoolSink = { size: 0 };
     let selectedResultPartition: RecallResultPartition | null = null;
     let identityInjectionModeUsed: IdentityInjectionMode | "none" = "none";
@@ -1908,6 +1895,19 @@ export class RecallInternalCoordinator {
       degradations?: SearchDegradation[];
     } | null;
 
+    // Cross-lingual recall (#2197): computed beside the prefilter; never
+    // throws — a failed corpus sample only skips the plan.
+    const crossScriptPlanPromise = (async () => {
+      const queryLanguage = detectLanguageHint(retrievalQuery);
+      if (queryLanguage === undefined) return null;
+      const corpusLanguage = await dominantCorpusLanguage(this.deps.storage);
+      if (corpusLanguage === undefined) return null;
+      return planCrossScript({
+        queryLanguage,
+        corpusLanguage,
+        vectorTierAvailable: resolveMemoryLifecycleCapabilities(this.deps.config).embeddingFallback,
+      });
+    })().catch(() => null);
     const qmdEnrichmentAbort = createEnrichmentAbortHandle(options.abortSignal);
     const qmdPromise = observeEnrichmentPromise(
       (async (): Promise<QmdPhaseResult> => {
@@ -1989,7 +1989,11 @@ export class RecallInternalCoordinator {
           }
           return cachedQmd.value;
         }
-
+        const crossScriptPlan = await crossScriptPlanPromise;
+        if (crossScriptPlan?.degradation) {
+          backendDegradations.push(crossScriptPlan.degradation);
+        }
+        const crossScript = crossScriptPlan?.crossScript === true;
         if (!this.deps.qmd.isAvailable()) {
           const now = Date.now();
           const QMD_REPROBE_COOLDOWN_MS = 60_000;
@@ -2141,6 +2145,7 @@ export class RecallInternalCoordinator {
                 resolveNamespace: (p) => this.deps.namespaceFromPath(p),
                 queryAwarePrefilter,
                 searchOptions: qmdSearchOptions,
+                crossScript,
                 abortSignal: qmdEnrichmentAbort.signal,
                 onDegradation: (degradation) => {
                   backendDegradations.push(degradation);
@@ -2666,6 +2671,7 @@ export class RecallInternalCoordinator {
       return section;
     })();
 
+    const procedureInjectedMemories: Array<{ id: string; path: string; namespace?: string }> = [];
     const procedureRecallPromise = (async (): Promise<string | null> => {
       if (this.deps.config.procedural?.enabled !== true) return null;
       if (!this.deps.isRecallSectionEnabled("procedure-recall", true)) return null;
@@ -2674,10 +2680,7 @@ export class RecallInternalCoordinator {
           profileStorage,
           retrievalQuery,
           this.deps.config,
-          {
-            partitionToolScoped: lifecycleCaps.extractionScopeClassification,
-            requestingConnector: options.sourceConnector,
-          },
+          { partitionToolScoped: lifecycleCaps.extractionScopeClassification, requestingConnector: options.sourceConnector, injectedMemories: procedureInjectedMemories },
         );
       } catch (err) {
         log.debug(
@@ -4105,8 +4108,6 @@ export class RecallInternalCoordinator {
               undefined,
               { asOfMs, requestingConnector: options.sourceConnector },
             );
-            // MMR runs on the pre-truncation pool so diverse candidates just
-            // below the cutoff can be promoted into the injected set.
             xrayBranchPoolSize.hot_embedding = Math.max(
               xrayBranchPoolSize.hot_embedding,
               boostedScoped.length,
@@ -4319,8 +4320,7 @@ export class RecallInternalCoordinator {
               undefined,
               { asOfMs, requestingConnector: options.sourceConnector },
             );
-            // MMR runs on the pre-truncation pool so diverse candidates just
-            // below the cutoff can be promoted into the injected set.
+            // MMR runs on the pre-truncation pool (see the hot-embedding branch).
             xrayBranchPoolSize.hot_embedding = Math.max(
               xrayBranchPoolSize.hot_embedding,
               boostedScoped.length,
@@ -4944,6 +4944,9 @@ export class RecallInternalCoordinator {
     const assembledRecall = this.deps.assembleRecallSections(
       sectionBuckets, contextBudgetForFooter(recallBudgetChars, curiosityFooter),
     );
+    if (procedureRecallSection !== null && assembledRecall.includedIds.includes("procedure-recall")) {
+      assembledRecall.includedMemories = mergeProcedureInjections(assembledRecall.includedMemories, procedureInjectedMemories);
+    }
     recalledMemoryIds = assembledRecall.includedMemories.map((memory) => memory.id);
     recalledMemoryPaths = assembledRecall.includedMemories.map((memory) => memory.path);
     recalledMemoryNamespaces = assembledRecall.includedMemories.map((memory) => memory.namespace);

package/src/orchestration/recall-search-pipeline.ts

@@ -281,6 +281,8 @@ export class RecallSearchPipelineCoordinator {
       searchOptions?: SearchQueryOptions;
       onDebugSnapshot?: (snapshot: QmdRecallSnapshot) => Promise<void>;
       /** Backend degradation observer, threaded into every QMD call (#1536). */
+      /** Cross-lingual plan flag (#2197): supplement the lexical page with vector-tier hits. */
+      crossScript?: boolean;
       onDegradation?: (degradation: SearchDegradation) => void;
       abortSignal?: AbortSignal;
     },
@@ -334,6 +336,12 @@ export class RecallSearchPipelineCoordinator {
     const debugSearchOptions = backendHonorsQmdSearchSignals
       ? resolvedSearchOptions
       : undefined;
+    // Cross-lingual recall (#2197): lexical tiers cannot match a query whose
+    // dominant script differs from the corpus's, whatever the page fill.
+    // Supplement with the embedding-fallback tier ONCE, before widening.
+    const crossScriptVectorHits = options.crossScript
+      ? await this.searchEmbeddingFallback(prompt, fetchLimit)
+      : [];
     let bestFiltered = filterRecallCandidates(scopedSeedResults, {
       namespacesEnabled: options.namespacesEnabled,
       recallNamespaces: options.recallNamespaces,
@@ -475,6 +483,14 @@ export class RecallSearchPipelineCoordinator {
         }
       }
 
+      if (crossScriptVectorHits.length > 0) {
+        mergedResults = dedupeResultsByNamespace(
+          [...mergedResults, ...crossScriptVectorHits],
+          this.deps.namespaceFromPath,
+          fetchLimit,
+          { filter: recallable },
+        );
+      }
       if (scopedSeedResults.length > 0) {
         mergedResults = dedupeResultsByNamespace(
           [...scopedSeedResults, ...mergedResults],