@remnic/core 9.48.1 → 9.49.1

package/src/orchestration/extraction-persist.ts

@@ -37,6 +37,8 @@ import { semanticChunkContent, type SemanticChunkResult } from "../semantic-chun
 import { isAboveImportanceThreshold, scoreImportance } from "../importance.js";
 import { sanitizeMemoryContent } from "../sanitize.js";
 import {
+  resolveCapabilities,
+  resolveConsolidationCapabilities,
   resolveGraphConstructionCapabilities,
   resolveMemoryLifecycleCapabilities,
   resolvePipelineProcessingCapabilities,
@@ -90,6 +92,7 @@ import {
 import { buildProcedurePersistBody } from "../procedural/procedure-types.js";
 import { stripAttributesSuffix } from "../structured-attributes.js";
 import { LocalLlmClient } from "../local-llm.js";
+import type { ExtractionEngine } from "../extraction.js";
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
@@ -117,106 +120,17 @@ import {
   readActiveMemoriesBothTiers,
   shouldPromoteToShared,
 } from "./extraction-persist-promotion.js";
+import type { ExtractionPersistDeps } from "./extraction-persist-deps.js";
 import type { ResolvedScopeProfilePlan } from "../namespaces/scope-profiles.js";
 import {
   buildMemoryPathById,
   appendMemoryToGraphContext,
   resolvePersistedMemoryRelativePath,
 } from "../orchestrator.js";
+import type { HarmonicConstructionInput } from "../harmonic-construction.js";
+import { persistConstructedHarmonicRecords } from "./harmonic-construction-persist.js";
+
 
-export interface ExtractionPersistDeps {
-  config: PluginConfig;
-  getStorageRouter: () => NamespaceStorageRouter;
-  getThreading: () => ThreadingManager;
-  getLocalLlm: () => LocalLlmClient;
-  getQmd: () => SearchBackend;
-  getJudgeVerdictCache: () => Map<string, JudgeVerdict>;
-  getJudgeDeferCounts: () => Map<string, number>;
-  getFaithfulnessCounters: () => FaithfulnessGateCounters;
-  getEmbeddingFallback: () => EmbeddingFallback;
-  setLastPersistExtractionDeferredCount: (value: number) => void;
-  setLastPersistExtractionPendingReviewIds: (ids: string[]) => void;
-  addContentHashDedup: (targetStorage: StorageManager, content: string) => Promise<void>;
-  hasContentHashDedup: (targetStorage: StorageManager, content: string) => Promise<boolean>;
-  backfillTemporalBoundsOnDedupHit: (
-    targetStorage: StorageManager,
-    dedupContent: string,
-    bounds: {
-      invalidAt?: string;
-      validFrom?: string;
-      observedAt?: string;
-      eventTimeSource?: "extracted" | "assumed";
-    },
-    entityRef?: string,
-    sourceConnector?: string,
-  ) => Promise<void>;
-  saveContentHashIndexes: () => Promise<void>;
-  artifactTypeForCategory: (
-    category: string,
-  ) =>
-    | "decision"
-    | "constraint"
-    | "todo"
-    | "definition"
-    | "commitment"
-    | "correction"
-    | "fact";
-  loadRoutingRules: () => Promise<RouteRule[]>;
-  routeEngineOptions: () => RoutingEngineOptions;
-  semanticDedupLookup: (
-    content: string,
-    limit: number,
-    targetStorage: StorageManager,
-  ) => Promise<SemanticDedupHit[]>;
-  checkForContradiction: (
-    content: string,
-    category: string,
-    namespaceScope: string,
-  ) => Promise<{
-    supersededId: string;
-    confidence: number;
-    reason: string;
-    supersededPath: string;
-    supersededCreated: string;
-    supersededTags: string[];
-  } | null>;
-  applyDeferredContradictionResolve: (
-    contradiction: {
-      supersededId: string;
-      reason: string;
-      supersededPath: string;
-      supersededCreated: string;
-      supersededTags: string[];
-    } | null | undefined,
-    storage: StorageManager,
-    newMemoryId: string,
-    postWriteGuard: boolean,
-  ) => Promise<void>;
-  suggestLinksForMemory: (
-    content: string,
-    category: string,
-    namespaceScope: string,
-  ) => Promise<MemoryLink[]>;
-  storageDirNamespace: (storageDir: string) => string;
-  indexPersistedMemory: (storage: StorageManager, memoryId: string) => Promise<void>;
-  buildGraphEdge: (
-    storage: StorageManager,
-    memoryRelPath: string,
-    entityRef: string | undefined,
-    memoryId: string,
-    factContent: string,
-    allMemsForGraph: MemoryFile[] | null | undefined,
-    memoryPathById: Map<string, string>,
-    threadIdForEdge: string | undefined,
-    threadEpisodeIdsForGraph: string[] | undefined,
-    fallbackCausalPredecessor: string | undefined,
-    graphCaps?: GraphConstructionCapabilitySet,
-  ) => Promise<void>;
-  updateTemporalTagIndexes: (
-    storage: StorageManager,
-    persistedIds: string[],
-  ) => Promise<void>;
-}
 
 export class ExtractionPersistCoordinator {
   constructor(
@@ -254,6 +168,20 @@ export class ExtractionPersistCoordinator {
     // ensureFactHashIndexAuthoritative), so a deferred write, crash, or
     // multi-process interleave is safe by construction with no marker to guard.
     const factDedupEnabled = resolveRecallAuxiliaryCapabilities(this.deps.config).factDeduplication;
+    const harmonicConstructionEnabled = resolveCapabilities(this.deps.config).harmonicRetrieval;
+    const harmonicAnchorsEnabled =
+      resolveConsolidationCapabilities(this.deps.config).abstractionAnchors;
+    const harmonicBaseNamespace =
+      baseNamespace ?? this.deps.storageDirNamespace(storage.dir);
+    const harmonicFactsByStorage = new Map<
+      string,
+      {
+        storage: StorageManager;
+        facts: HarmonicConstructionInput["persistedFacts"];
+      }
+    >();
+    const harmonicSourceInsertedAtBase = Date.now();
+    let harmonicSourceOrder = 0;
 
   // Canonicalize stored content for dedup comparison: strip citations
   // (using the same template), sanitize, then normalize whitespace.
@@ -304,6 +232,10 @@ export class ExtractionPersistCoordinator {
         /** #1635: keep this id out of the persisted thread episode set. */
         pendingReview?: boolean;
         category?: MemoryCategory;
+        harmonicFact?: Omit<
+          HarmonicConstructionInput["persistedFacts"][number],
+          "memoryId"
+        >;
       } = {},
     ): void => {
       if (options.includeReturnedIds !== false) {
@@ -319,6 +251,23 @@ export class ExtractionPersistCoordinator {
       } else {
         persistedIdsByStorage.set(key, { storage: targetStorage, ids: [id] });
       }
+      if (
+        harmonicConstructionEnabled &&
+        options.harmonicFact &&
+        !options.pendingReview
+      ) {
+        const harmonicEntry = harmonicFactsByStorage.get(key) ?? {
+          storage: targetStorage,
+          facts: [],
+        };
+        harmonicEntry.facts.push({
+          ...options.harmonicFact,
+          memoryId: id,
+          insertedAt: new Date(harmonicSourceInsertedAtBase + harmonicSourceOrder).toISOString(),
+        });
+        harmonicSourceOrder++;
+        harmonicFactsByStorage.set(key, harmonicEntry);
+      }
       if (options.category && !memoryPathById.has(id)) {
         const relPath = resolvePersistedMemoryRelativePath({ memoryId: id, pathById: memoryPathById, category: options.category });
         memoryPathById.set(id, relPath);
@@ -420,6 +369,10 @@ export class ExtractionPersistCoordinator {
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
       toolScoped?: true;
+      harmonicFact?: Omit<
+        HarmonicConstructionInput["persistedFacts"][number],
+        "memoryId"
+      >;
     }): Promise<void> => {
       if (
         !scopeProfileWritePlan ||
@@ -558,6 +511,9 @@ export class ExtractionPersistCoordinator {
                 structuredAttributes: { ...targetSurvivingAttrs },
                 createdAt: supersessionOrderingAt(options.validAt),
                 enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
+                extraction: this.deps.getExtraction(),
+                config: this.config,
+                namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
               });
             } catch (profileSupersessionErr) {
               log.warn(
@@ -568,7 +524,11 @@ export class ExtractionPersistCoordinator {
           // #1645 TV6: a tombstone-blocked promotion is pending_review (no
           // active copy) — skip catalog/index/behavior like postWriteGuard.
           if (!targetPromotion.tombstoneBlocked) {
-            trackPersistedId(targetStorage, promotedId, { includeReturnedIds: false, category: options.category as MemoryCategory });
+            trackPersistedId(targetStorage, promotedId, {
+              includeReturnedIds: false,
+              category: options.category as MemoryCategory,
+              harmonicFact: options.harmonicFact,
+            });
             await this.deps.indexPersistedMemory(targetStorage, promotedId);
             trackBehaviorSignals(
               targetStorage,
@@ -616,6 +576,10 @@ export class ExtractionPersistCoordinator {
       /** Claim-level provenance spans (issue #1575 PR 2). */
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
+      harmonicFact?: Omit<
+        HarmonicConstructionInput["persistedFacts"][number],
+        "memoryId"
+      >;
     }): Promise<void> => {
       const toolScoped = withholdToolScopedFromSharedNamespace(options);
       await promoteMemoryToProfileTargets({
@@ -849,6 +813,9 @@ export class ExtractionPersistCoordinator {
                   createdAt: supersessionOrderingAt(options.validAt),
                   enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
                   useCallerTimestamp: true,
+                  extraction: this.deps.getExtraction(),
+                  config: this.config,
+                  namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir),
                 });
                 // Catalog touch (issue #1499 — codex P2 NElSf): this dedup branch
                 // returns WITHOUT the post-write catalog touch (now at the storage chokepoint #1522),
@@ -971,6 +938,9 @@ export class ExtractionPersistCoordinator {
               structuredAttributes: { ...sharedSurvivingAttrs },
               createdAt: supersessionOrderingAt(options.validAt),
               enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
+              extraction: this.deps.getExtraction(),
+              config: this.config,
+              namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir),
             });
           } catch (sharedSupersessionErr) {
             log.warn(
@@ -992,6 +962,7 @@ export class ExtractionPersistCoordinator {
           trackPersistedId(sharedStorage, promotedId, {
             includeReturnedIds: false,
             category: options.category as MemoryCategory,
+            harmonicFact: options.harmonicFact,
           });
           await this.deps.indexPersistedMemory(sharedStorage, promotedId);
           trackBehaviorSignals(
@@ -1650,6 +1621,17 @@ export class ExtractionPersistCoordinator {
           );
         }
       }
+      const harmonicFact: Omit<
+        HarmonicConstructionInput["persistedFacts"][number],
+        "memoryId"
+      > = {
+        category: writeCategory,
+        content: fact.content,
+        tags: fact.tags,
+        cueAnchors: fact.cueAnchors,
+        entityRef: fact.entityRef,
+        validAt: biTemporal?.validFrom ?? sourceContext?.validAt,
+      };
       // #1669 redaction-rule gate: consult BOTH source and target namespace
       // rules before any write. A never-store pattern registered under the
       // source namespace must survive scope-routing to a different target
@@ -2346,6 +2328,7 @@ export class ExtractionPersistCoordinator {
           trackPersistedId(targetStorage, parentId, {
             pendingReview: postWriteGuard,
             category: writeCategory,
+            harmonicFact,
           });
           // #1576 (cursor Medium): keep pending_review ids out of threadEpisodeIdsForGraph — else later active facts build thread-predecessor edges to an unfaithful memory.
           if (
@@ -2383,6 +2366,9 @@ export class ExtractionPersistCoordinator {
                 // supersede a later active fact (codex P1 on :15534).
                 enabled: lifecycleCaps.temporalSupersession &&
                   !(biTemporal && !biTemporal.validFrom),
+                extraction: this.deps.getExtraction(),
+                config: this.config,
+                namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
               });
             } catch (err) {
               log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
@@ -2418,6 +2404,7 @@ export class ExtractionPersistCoordinator {
             ...(fact.procedureSteps && fact.procedureSteps.length ? { procedureSteps: fact.procedureSteps } : {}),
             ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
             ...(fact.provenance ? { provenance: fact.provenance } : {}),
+            harmonicFact,
           });
           // Register chunked content in the target storage hash index too.
           // Thread 3 fix: canonicalize by stripping any pre-existing citation
@@ -2654,6 +2641,9 @@ export class ExtractionPersistCoordinator {
             createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
             enabled: lifecycleCaps.temporalSupersession &&
               !(biTemporal && !biTemporal.validFrom),
+            extraction: this.deps.getExtraction(),
+            config: this.config,
+            namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
           });
         } catch (err) {
           log.warn(`temporal-supersession: unexpected error: ${err}`);
@@ -2674,6 +2664,7 @@ export class ExtractionPersistCoordinator {
         trackPersistedId(targetStorage, memoryId, {
           pendingReview: postWriteGuard,
           category: writeCategory,
+          harmonicFact,
         });
         if (
           !postWriteGuard &&
@@ -2721,6 +2712,7 @@ export class ExtractionPersistCoordinator {
           ...(fact.procedureSteps && fact.procedureSteps.length ? { procedureSteps: fact.procedureSteps } : {}),
           ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
           ...(fact.provenance ? { provenance: fact.provenance } : {}),
+          harmonicFact,
         });
         // v8.2: graph edge building (fail-open). #1576: skip pending_review facts.
         if (graphCaps.multiGraphMemory && !postWriteGuard) {
@@ -2994,6 +2986,21 @@ export class ExtractionPersistCoordinator {
     log.info(
       `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`,
     );
+    if (harmonicConstructionEnabled && harmonicFactsByStorage.size > 0) {
+      await persistConstructedHarmonicRecords({
+        entries: harmonicFactsByStorage.values(),
+        baseStorageDir: storage.dir,
+        abstractionNodeStoreDir:
+          !scopeProfileWritePlan && harmonicBaseNamespace === this.deps.config.defaultNamespace
+            ? this.deps.config.abstractionNodeStoreDir
+            : undefined,
+        sessionKey: sourceContext?.sessionKey,
+        validAt: sourceContext?.validAt,
+        episodeTitle: result.episodeTitle,
+        anchorsEnabled: harmonicAnchorsEnabled,
+        entityMentions: entities,
+      });
+    }
     // Update temporal + tag indexes (v8.1) — fire-and-forget, fail-open
     void (async () => {
       if (persistedIdsByStorage.size === 0) {

package/src/orchestration/harmonic-construction-persist.ts

@@ -0,0 +1,86 @@
+import {
+  type HarmonicConstructionInput,
+  deriveHarmonicRecords,
+  harmonicEntityReferenceMatches,
+  harmonicEntitySegment,
+  normalizedHarmonicEntityIdentity,
+  persistHarmonicRecords,
+} from "../harmonic-construction.js";
+import { log } from "../logger.js";
+import type { ExtractionResult } from "../types.js";
+
+export interface HarmonicPersistenceEntry {
+  storage: { dir: string };
+  facts: HarmonicConstructionInput["persistedFacts"];
+}
+
+export function filterHarmonicEntityMentions(
+  facts: HarmonicConstructionInput["persistedFacts"],
+  entityMentions: ExtractionResult["entities"]
+): ExtractionResult["entities"] {
+  const identitiesBySegment = new Map<string, Set<string>>();
+  for (const entity of entityMentions) {
+    const segment = harmonicEntitySegment(entity.name);
+    const identities = identitiesBySegment.get(segment) ?? new Set<string>();
+    identities.add(normalizedHarmonicEntityIdentity(entity.name));
+    identitiesBySegment.set(segment, identities);
+  }
+  return entityMentions.flatMap((entity) => {
+    const allowSegmentFallback = identitiesBySegment.get(harmonicEntitySegment(entity.name))?.size === 1;
+    const activeFacts = facts.filter(
+      (fact) =>
+        typeof fact.entityRef === "string" &&
+        harmonicEntityReferenceMatches(fact.entityRef, entity.name, allowSegmentFallback)
+    );
+    return activeFacts.length > 0 ? [{ ...entity, facts: activeFacts.map((fact) => fact.content) }] : [];
+  });
+}
+
+export async function persistConstructedHarmonicRecords(options: {
+  entries: Iterable<HarmonicPersistenceEntry>;
+  baseStorageDir: string;
+  abstractionNodeStoreDir?: string;
+  sessionKey?: string;
+  validAt?: string;
+  episodeTitle?: string;
+  anchorsEnabled: boolean;
+  entityMentions: ExtractionResult["entities"];
+}): Promise<void> {
+  const sessionKey = options.sessionKey?.trim();
+  if (!sessionKey) {
+    log.warn("harmonic construction skipped: extraction session key is missing");
+    return;
+  }
+  const recordedAt =
+    options.validAt && Number.isFinite(Date.parse(options.validAt))
+      ? new Date(options.validAt).toISOString()
+      : new Date().toISOString();
+  const entries = [...options.entries];
+  const sharedEpisodeTitle = entries.length === 1 ? options.episodeTitle : undefined;
+  for (const entry of entries) {
+    try {
+      const records = deriveHarmonicRecords({
+        sessionKey,
+        recordedAt,
+        episodeTitle: sharedEpisodeTitle,
+        persistedFacts: entry.facts,
+        entityMentions: filterHarmonicEntityMentions(entry.facts, options.entityMentions).map((entity) => ({
+          name: entity.name,
+          type: entity.type,
+          facts: entity.facts,
+        })),
+      });
+      await persistHarmonicRecords({
+        memoryDir: entry.storage.dir,
+        abstractionNodeStoreDir:
+          entry.storage.dir === options.baseStorageDir ? options.abstractionNodeStoreDir : undefined,
+        nodes: records.nodes,
+        anchors: options.anchorsEnabled ? records.anchors : [],
+      });
+    } catch (error) {
+      log.warn(
+        `harmonic construction failed open for namespace ${entry.storage.dir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}

package/src/orchestration/namespace-read-fanout.ts

@@ -27,6 +27,7 @@ import { mergeArtifactRecallCandidates, tokenizeRecallQuery } from "./orchestrat
 import { qmdCollectionPathParts } from "./qmd-result-resolver.js";
 import { qmdCollectionNamespaceFromPrefix as computeQmdCollectionNamespaceFromPrefix } from "./orchestrator-namespace-scope.js";
 import { resolveNamespaceFromStorageDir } from "../scopes/scope-plan.js";
+import { checkCorpusReadAbort, type CorpusReadOptions } from "../corpus-read-cancellation.js";
 import type { ArtifactRecallOptions } from "./recall-search-prefilter.js";
 import type { SearchBackend, SearchExecutionOptions, SearchQueryOptions } from "../search/port.js";
 import type { MemoryFile, PluginConfig, QmdSearchResult } from "../types.js";
@@ -247,7 +248,9 @@ export class NamespaceReadFanoutCoordinator {
   async resolveArtifactSourceStatuses(
     storage: StorageManager,
     sourceIds: string[],
+    options?: CorpusReadOptions,
   ): Promise<Map<string, "active" | "superseded" | "archived" | "missing">> {
+    checkCorpusReadAbort(options);
     const currentStatusVersion = storage.getMemoryStatusVersion();
     const cached = this.deps.artifactSourceStatusCache.get(storage);
     let snapshot = cached;
@@ -266,8 +269,15 @@ export class NamespaceReadFanoutCoordinator {
       let latestVersionAfter = storage.getMemoryStatusVersion();
 
       for (let attempt = 0; attempt < MAX_STABLE_READ_ATTEMPTS; attempt += 1) {
+        // Each attempt is a full corpus read; an abandoned caller must not buy a
+        // second or third one (issue #2307).
+        checkCorpusReadAbort(options);
         const versionBefore = storage.getMemoryStatusVersion();
-        const allMemories = await storage.readAllMemories();
+        const allMemories = await storage.readAllMemories(options);
+        // An abort landing between the read and the publish below would otherwise
+        // cache and return a snapshot to a caller that had already cancelled
+        // (issue #2307 review).
+        checkCorpusReadAbort(options);
         const versionAfter = storage.getMemoryStatusVersion();
         latestVersionAfter = versionAfter;
         latestStatuses = new Map(
@@ -467,12 +477,13 @@ export class NamespaceReadFanoutCoordinator {
 
   async readAllMemoriesForNamespaces(
     namespaces: string[],
+    options?: CorpusReadOptions,
   ): Promise<MemoryFile[]> {
     const uniq = Array.from(new Set(namespaces.filter(Boolean)));
     const lists = await Promise.all(
       uniq.map(async (ns) => {
         const sm = await this.deps.storageRouter.storageFor(ns);
-        return sm.readAllMemories();
+        return sm.readAllMemories(options);
       }),
     );
     return lists.flat();

package/src/orchestration/recall-internal-deps.ts

@@ -17,6 +17,7 @@ import type { NamespaceCatalog } from "../namespaces/catalog.js";
 import type { NamespaceStorageRouter } from "../namespaces/storage.js";
 import type { ObjectiveStateSearchResult } from "../objective-state.js";
 import type { IntentDebugSnapshot, QmdRecallSnapshot, QueryAwarePrefilter } from "../orchestrator.js";
+import type { CorpusReadOptions } from "../corpus-read-cancellation.js";
 import type { ProfilingCollector } from "../profiling.js";
 import type { GraphRecallExpandedEntry, LastRecallBudgetSummary, LastRecallStore, RecallHandleHistoryStore } from "../recall-state.js";
 import type { RecallXraySnapshot } from "../recall-xray.js";
@@ -335,6 +336,7 @@ export interface RecallInternalDeps {
   ): void;
   readAllMemoriesForNamespaces(
     namespaces: string[],
+    options?: CorpusReadOptions,
   ): Promise<MemoryFile[]>;
   recallArtifactsAcrossNamespaces(
     prompt: string,

package/src/orchestration/recall-internal.ts

@@ -1551,6 +1551,7 @@ export class RecallInternalCoordinator {
               maxResults,
               sessionKey,
               anchorsEnabled: resolveConsolidationCapabilities(this.deps.config).abstractionAnchors,
+              temporalExpiredInInjection: this.deps.config.temporalExpiredInInjection,
               abortSignal: harmonicRetrievalAbort.signal,
             }),
           ),
@@ -4414,7 +4415,10 @@ export class RecallInternalCoordinator {
       } else {
         const memories = await awaitAssemblyStep(
           "recent-memory-read",
-          () => this.deps.readAllMemoriesForNamespaces(recallNamespaces),
+          (stepSignal) =>
+            this.deps.readAllMemoriesForNamespaces(recallNamespaces, {
+              abortSignal: stepSignal,
+            }),
           [] as MemoryFile[],
         );
         if (memories.length > 0) {

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

@@ -34,6 +34,7 @@ import { RerankCache, rerankLocalOrNoop, reorderByRankedKeys } from "../rerank.j
 import type { SearchBackend, SearchDegradation, SearchExecutionOptions, SearchQueryOptions } from "../search/port.js";
 import { SecureStoreLockedError } from "../secure-store/index.js";
 import { isPathInsideStorageRoot } from "../storage-paths.js";
+import type { CorpusReadOptions } from "../corpus-read-cancellation.js";
 import { extractTagsFromPrompt, isTemporalQuery, queryByDateRangeAsync, queryByTagsAsync, readIndexSnapshotAsync, recencyWindowFromPrompt } from "../temporal-index.js";
 import {
   buildQueryAwarePrefilter as buildQueryAwarePrefilterHelper,
@@ -206,6 +207,7 @@ export interface RecallSearchPipelineDeps {
   resolveArtifactSourceStatuses(
     storage: StorageManager,
     sourceIds: string[],
+    options?: CorpusReadOptions,
   ): Promise<Map<string, "active" | "superseded" | "archived" | "missing">>;
   resolveColdQmdResultForRecall(
     result: QmdSearchResult,

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { resolveIndexingCapabilities, resolveMemoryLifecycleCapabilities } from "../capabilities.js";
 import type { EmbeddingFallback } from "../embedding-fallback.js";
+import type { CorpusReadOptions } from "../corpus-read-cancellation.js";
 import type { StorageManager } from "../index.js";
 import type { NamespaceStorageRouter } from "../namespaces/storage.js";
 import {
@@ -27,6 +28,7 @@ export interface PrefilterAndArtifactDeps {
   resolveArtifactSourceStatuses(
     storage: StorageManager,
     sourceIds: string[],
+    options?: CorpusReadOptions,
   ): Promise<Map<string, "active" | "superseded" | "archived" | "missing">>;
   scopeQueryAwarePaths(
     paths: Set<string> | null,
@@ -84,7 +86,9 @@ export async function fetchActiveArtifactsForNamespace(
     throwIfRecallAborted(options.abortSignal);
     const sourceStatus =
       sourceIds.length > 0
-        ? await deps.resolveArtifactSourceStatuses(storage, sourceIds)
+        ? await deps.resolveArtifactSourceStatuses(storage, sourceIds, {
+            abortSignal: options.abortSignal,
+          })
         : new Map<string, "active" | "superseded" | "archived" | "missing">();
 
     const filtered: MemoryFile[] = [];

package/src/orchestrator.ts

@@ -121,6 +121,7 @@ import { ExtractionPersistCoordinator } from "./orchestration/extraction-persist
 import { RecallInternalCoordinator } from "./orchestration/recall-internal.js";
 import { RecallSearchPipelineCoordinator } from "./orchestration/recall-search-pipeline.js";
 import type { ArtifactRecallOptions } from "./orchestration/recall-search-prefilter.js";
+import type { CorpusReadOptions } from "./corpus-read-cancellation.js";
 import { TurnIngestionCoordinator, type TurnIngestionOptions } from "./orchestration/turn-ingestion.js";
 import { RecallIntrospectionCoordinator } from "./orchestration/recall-introspection.js";
 import { OrchestratorInitCoordinator } from "./orchestration/orchestrator-init.js";
@@ -783,13 +784,13 @@ export class Orchestrator {
    * its own methods + coordinators.
    */
   private _consolidationRunCoordinator: ConsolidationRunCoordinator | undefined;
-
   private get consolidationRunCoordinator(): ConsolidationRunCoordinator {
     if (!this._consolidationRunCoordinator) {
       this._consolidationRunCoordinator = new ConsolidationRunCoordinator({
         config: this.config,
         getStorage: () => this.storage,
         getStorageRouter: () => this.storageRouter,
+        getNamespaceCatalog: () => this.namespaceCatalog,
         getExtraction: () => this.extraction,
         embeddingFallback: this.embeddingFallback,
         tmtBuilder: this.tmtBuilder,
@@ -824,6 +825,7 @@ export class Orchestrator {
         getStorageRouter: () => this.storageRouter,
         getThreading: () => this.threading,
         getLocalLlm: () => this.localLlm,
+        getExtraction: () => this.extraction,
         getQmd: () => this.qmd,
         getJudgeVerdictCache: () => this.judgeVerdictCache,
         getJudgeDeferCounts: () => this.judgeDeferCounts,
@@ -1872,10 +1874,10 @@ export class Orchestrator {
   private async resolveArtifactSourceStatuses(
     storage: StorageManager,
     sourceIds: string[],
+    options?: CorpusReadOptions,
   ): Promise<Map<string, "active" | "superseded" | "archived" | "missing">> {
     return this.namespaceReadFanoutCoordinator.resolveArtifactSourceStatuses(
-      storage,
-      sourceIds,
+      storage, sourceIds, options,
     );
   }
 
@@ -3970,9 +3972,8 @@ export class Orchestrator {
 
   private async readAllMemoriesForNamespaces(
     namespaces: string[],
+    options?: CorpusReadOptions,
   ): Promise<MemoryFile[]> {
-    return this.namespaceReadFanoutCoordinator.readAllMemoriesForNamespaces(
-      namespaces,
-    );
+    return this.namespaceReadFanoutCoordinator.readAllMemoriesForNamespaces(namespaces, options);
   }
 }

package/src/schemas.ts

@@ -81,6 +81,16 @@ export const ExtractedFactSchema = z.object({
     .optional()
     .nullable()
     .describe("If about an entity, its normalized name (e.g. person-jane-doe)"),
+  cueAnchors: z
+    .array(
+      z.object({
+        type: z.enum(["entity", "file", "tool", "outcome", "constraint", "date"]),
+        value: z.string(),
+      }),
+    )
+    .optional()
+    .nullable()
+    .describe("Up to three short retrieval cues for this fact."),
   promptedByQuestion: z
     .string()
     .optional()
@@ -296,6 +306,11 @@ export const ExtractionResultSchema = z.object({
     .describe(
       "A brief reflection on what you learned about yourself as an agent in this interaction — patterns in your behavior, growth, things you did well or could improve.",
     ),
+  episodeTitle: z
+    .string()
+    .optional()
+    .nullable()
+    .describe("A six-to-eight word title for this conversation segment."),
   relationships: z
     .array(ExtractedRelationshipSchema)
     .optional()