@remnic/core 9.48.1 → 9.49.0

package/dist/storage.d.ts

@@ -1,6 +1,7 @@
 import './types-D_Au9qJO.js';
+import './corpus-read-cancellation.js';
 import './artifact-search.js';
-export { C as ContentHashIndex, t as ContentHashIndexLockOptions, u as FactHashIndexNotAuthoritativeError, v as MemoryLifecycleEventWriteOptions, M as MemoryWriteResult, R as ReextractJobRequest, w as SealedWriteExtras, S as StorageManager, W as WriteMemoryOptions, x as buildEntitySchemaCacheKey, y as compareEntityTimestamps, z as compileEntityFacts, A as countEntityStructuredFacts, B as fingerprintEntityStructuredFacts, D as isEntitySynthesisStale, E as isValidBufferSurpriseEvent, G as normalizeFrontmatterForPath, H as normalizeStructuredSectionFacts, p as parseEntityFile, I as parseFrontmatter, J as parseFrontmatterStringValue, s as serializeEntityFile } from './storage-COL907QF.js';
+export { C as ContentHashIndex, t as ContentHashIndexLockOptions, u as FactHashIndexNotAuthoritativeError, v as MemoryLifecycleEventWriteOptions, M as MemoryWriteResult, R as ReextractJobRequest, w as SealedWriteExtras, S as StorageManager, W as WriteMemoryOptions, x as buildEntitySchemaCacheKey, y as compareEntityTimestamps, z as compileEntityFacts, A as countEntityStructuredFacts, B as fingerprintEntityStructuredFacts, D as isEntitySynthesisStale, E as isValidBufferSurpriseEvent, G as normalizeFrontmatterForPath, H as normalizeStructuredSectionFacts, p as parseEntityFile, I as parseFrontmatter, J as parseFrontmatterStringValue, s as serializeEntityFile } from './storage-D1apCiCS.js';
 export { normalizeEntityName } from './entity-id-normalization.js';
 import './page-versioning.js';
 import './consolidation-operator.js';

package/dist/storage.js

@@ -13,16 +13,16 @@ import {
   parseFrontmatter,
   parseFrontmatterStringValue,
   serializeEntityFile
-} from "./chunk-PLCZD3LG.js";
+} from "./chunk-EY64JLOM.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-ENTCVTQR.js";
 import "./chunk-SXIMQLGV.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-3S63QIFQ.js";
+import "./chunk-SCU65EZI.js";
 import "./chunk-WRJVB3C2.js";
 import "./chunk-S2HLHAZ4.js";
-import "./chunk-SCU65EZI.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-JYIJNNN3.js";
@@ -37,10 +37,11 @@ import "./chunk-BT7NVCML.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
+import "./chunk-5GINB5LC.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-7YKVM5H3.js";
-import "./chunk-IJ7HK452.js";
-import "./chunk-PDJTHRAW.js";
+import "./chunk-RHTO4HTL.js";
+import "./chunk-KMAP7SNQ.js";
+import "./chunk-RBOJCG4T.js";
 import "./chunk-NZBZ7IS2.js";
 import "./chunk-DNHVPZOD.js";
 import "./chunk-6CIAGZ6X.js";

package/dist/temporal-supersession.d.ts

@@ -1,10 +1,11 @@
 import { l as MemoryFrontmatter } from './types-D_Au9qJO.js';
-import { S as StorageManager } from './storage-COL907QF.js';
+import { S as StorageManager } from './storage-D1apCiCS.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './types-continuity.js';
+import './corpus-read-cancellation.js';
 import './artifact-search.js';
 import './entity-id-normalization.js';
 import './page-versioning.js';

package/dist/tier-migration.d.ts

@@ -1,5 +1,5 @@
 import { M as MemoryFile } from './types-D_Au9qJO.js';
-import { S as StorageManager } from './storage-COL907QF.js';
+import { S as StorageManager } from './storage-D1apCiCS.js';
 import { MemoryTier } from './tier-routing.js';
 import { SearchBackend } from './search/port.js';
 import './message-parts/index.js';
@@ -7,6 +7,7 @@ import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './types-continuity.js';
+import './corpus-read-cancellation.js';
 import './artifact-search.js';
 import './entity-id-normalization.js';
 import './page-versioning.js';

package/dist/transfer/backup.js

@@ -1,8 +1,8 @@
 import {
   backupMemoryDir
-} from "../chunk-2NLLXCJG.js";
+} from "../chunk-BXLOS5AJ.js";
 import "../chunk-765K3SAT.js";
-import "../chunk-X7Y7WX73.js";
+import "../chunk-DQEMWVMT.js";
 import "../chunk-J4EB7DNW.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";

package/dist/transfer/capsule-export.js

@@ -1,9 +1,9 @@
 import {
   exportCapsule,
   isValidCapsuleSince
-} from "../chunk-KQAFEZQX.js";
+} from "../chunk-VDX2J7OX.js";
 import "../chunk-WEHSQBFR.js";
-import "../chunk-X7Y7WX73.js";
+import "../chunk-DQEMWVMT.js";
 import "../chunk-J4EB7DNW.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";

package/dist/transfer/capsule-import.js

@@ -1,16 +1,16 @@
 import {
   importCapsule
-} from "../chunk-A4JMGKCD.js";
-import "../chunk-7YKVM5H3.js";
-import "../chunk-IJ7HK452.js";
-import "../chunk-PDJTHRAW.js";
+} from "../chunk-R5IGA2NH.js";
+import "../chunk-RHTO4HTL.js";
+import "../chunk-KMAP7SNQ.js";
+import "../chunk-RBOJCG4T.js";
 import "../chunk-NZBZ7IS2.js";
 import "../chunk-DNHVPZOD.js";
 import "../chunk-6CIAGZ6X.js";
 import "../chunk-XMMESCPD.js";
 import "../chunk-42JKGUFJ.js";
 import "../chunk-WEHSQBFR.js";
-import "../chunk-X7Y7WX73.js";
+import "../chunk-DQEMWVMT.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";

package/dist/verified-recall.js

@@ -1,18 +1,18 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-GD7UPIBG.js";
+} from "./chunk-RJV6Q2FT.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-PLCZD3LG.js";
+import "./chunk-EY64JLOM.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-ENTCVTQR.js";
 import "./chunk-SXIMQLGV.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-3S63QIFQ.js";
+import "./chunk-SCU65EZI.js";
 import "./chunk-WRJVB3C2.js";
 import "./chunk-S2HLHAZ4.js";
-import "./chunk-SCU65EZI.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-JYIJNNN3.js";
@@ -22,10 +22,11 @@ import "./chunk-CGASUJVP.js";
 import "./chunk-R3DJVOSM.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-YXZG5TVN.js";
+import "./chunk-5GINB5LC.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-7YKVM5H3.js";
-import "./chunk-IJ7HK452.js";
-import "./chunk-PDJTHRAW.js";
+import "./chunk-RHTO4HTL.js";
+import "./chunk-KMAP7SNQ.js";
+import "./chunk-RBOJCG4T.js";
 import "./chunk-NZBZ7IS2.js";
 import "./chunk-DNHVPZOD.js";
 import "./chunk-6CIAGZ6X.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.48.1",
+  "version": "9.49.0",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3096,7 +3096,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.48.1"
+    "@remnic/coding-graph": "^9.49.0"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/corpus-read-cancellation.ts

@@ -0,0 +1,42 @@
+/**
+ * Cancellation contract for the shared full-corpus read primitives (issue #2307).
+ *
+ * `readAllArtifactsCached`, `readAllEntityFiles`, `readAllMemories`, and the
+ * artifact source-status snapshot each walk and parse an entire memory tree. Issue
+ * #2291 bounded the recall providers that call them, so a timed-out recall returns
+ * on time — but the scan underneath kept running, and for the primitives without
+ * in-flight coalescing every abandoned request started another one. On a large or
+ * network-mounted store those pile up into sustained I/O no live request needs.
+ *
+ * The mechanism is a plain optional parameter, not ambient async context: these
+ * primitives have dozens of callers across extraction, maintenance, wearables, and
+ * coding surfaces, and an ambient signal would silently attach a request's
+ * cancellation to background work that merely shares its async context. An
+ * explicit parameter is greppable, and a caller that does not opt in behaves
+ * exactly as before.
+ *
+ * Two invariants bind every implementation:
+ *
+ *  1. **Checked before the cache lookup.** A caller that has already given up gets
+ *     an `AbortError`, warm cache or not — the same contract the recall providers
+ *     follow, so cancellation never depends on cache state.
+ *  2. **A cancelled read never publishes.** Every checkpoint throws, so control
+ *     leaves before the cache write. A partial corpus must never be cached, or
+ *     served, as if it were complete.
+ */
+
+import { throwIfAborted } from "./abort-error.js";
+
+export interface CorpusReadOptions {
+  /**
+   * Stops the read at its next directory, batch, or attempt boundary. A single
+   * in-flight file read is not interrupted; the boundaries are what bound the
+   * work, and on a tree large enough to matter there are thousands of them.
+   */
+  abortSignal?: AbortSignal;
+}
+
+/** Stop a corpus read at a scan boundary when its caller has given up. */
+export function checkCorpusReadAbort(options?: CorpusReadOptions): void {
+  throwIfAborted(options?.abortSignal, "corpus read aborted");
+}

package/src/entity-retrieval.ts

@@ -550,12 +550,12 @@ async function buildEntityMentionIndex(
   const entityStatusVersionBefore = shouldPersistIndex ? storage.getMemoryStatusVersion() : undefined;
   const [previousIndex, entityFileSets, memorySets, nativeChunks] = await Promise.all([
     shouldPersistIndex ? readEntityIndexState(storage) : Promise.resolve(null),
-    Promise.all(storages.map((scopedStorage) => scopedStorage.readAllEntityFiles())),
-    Promise.all(storages.map((scopedStorage) => scopedStorage.readAllMemories())),
+    Promise.all(storages.map((scopedStorage) => scopedStorage.readAllEntityFiles({ abortSignal }))),
+    Promise.all(storages.map((scopedStorage) => scopedStorage.readAllMemories({ abortSignal }))),
     nativeChunksOverride ? Promise.resolve(nativeChunksOverride) : readNativeChunks(config, recallNamespaces),
   ]);
-  // The bulk reads above cannot be interrupted mid-flight; stop before spending
-  // the (larger) indexing pass over their results.
+  // The bulk reads now stop at their own scan boundaries (issue #2307); this
+  // checkpoint still guards the (larger) indexing pass over their results.
   checkEntityRecallAbort(abortSignal);
   // Pair each entity with the storage that owns it (#1534): canonical ids must
   // reflect that store's aliases and historical migration mappings, never another

package/src/in-flight-reads.ts

@@ -14,8 +14,20 @@ import type { MemoryFile } from "./types.js";
  * an unlocked manager's decrypted scan must NOT be handed to a locked or
  * differently-keyed manager for the same dir — that would bypass the keyId
  * isolation getCachedMemories enforces. Locked/plaintext stores use keyId "".
+ *
+ * Since issue #2307 the registry also owns the scan's CANCELLATION, because
+ * whether a shared scan may be cancelled is purely a question of who is still
+ * attached to it — see `beginCoalescedScan`.
  */
-const inFlightReadsByKey = new Map<string, Promise<MemoryFile[]>>();
+type InFlightEntry = {
+  read: Promise<MemoryFile[]>;
+  /** Readers still awaiting this scan. At zero the scan has no reason to finish. */
+  waiters: number;
+  /** Withdraw the slot and abort the scan. Absent for an uncancellable scan. */
+  cancel?: () => void;
+};
+
+const inFlightReadsByKey = new Map<string, InFlightEntry>();
 
 const DIR_SEP = "\u0000";
 
@@ -23,12 +35,113 @@ function composeKey(baseDir: string, keyId: string): string {
   return `${baseDir}${DIR_SEP}${keyId}`;
 }
 
-export function getInFlightRead(baseDir: string, keyId = ""): Promise<MemoryFile[]> | undefined {
-  return inFlightReadsByKey.get(composeKey(baseDir, keyId));
+/**
+ * A reader's attachment to a shared scan. `leave()` is idempotent per reader and
+ * must be called when that reader stops waiting — because its own signal fired, or
+ * because the scan settled.
+ */
+export interface CoalescedScanWaiter {
+  leave(): void;
+}
+
+/**
+ * Cancellation lifecycle for a coalesced corpus scan (issue #2307).
+ *
+ * The rule is reference counting, not ownership: **the scan is cancelled when its
+ * LAST waiter leaves, and never before.** One reader can therefore not cancel work
+ * another still needs, and two readers that both give up do not leave a full disk
+ * scan running for nobody — which was the abandoned I/O this whole change exists to
+ * remove.
+ *
+ * On the last leave the slot is withdrawn from the registry BEFORE the controller
+ * fires, so a reader arriving later cannot attach to a promise already doomed to
+ * reject with an `AbortError` it never asked for; it starts a fresh scan instead.
+ */
+export interface CoalescedScan extends CoalescedScanWaiter {
+  /** The signal the shared scan itself observes. */
+  readonly scanSignal: AbortSignal;
+  /** Publish the scan to the registry and arm cancellation. */
+  arm(read: Promise<MemoryFile[]>): void;
+}
+
+/** Build the per-reader `leave` closure: decrement once, cancel at zero. */
+function trackWaiter(entry: InFlightEntry, callerSignal?: AbortSignal): CoalescedScanWaiter {
+  let left = false;
+  const leave = () => {
+    if (left) return;
+    left = true;
+    callerSignal?.removeEventListener("abort", onAbort);
+    entry.waiters -= 1;
+    if (entry.waiters <= 0) entry.cancel?.();
+  };
+  // Named so the listener can be removed again; `once` alone would leak the
+  // reference for a reader that leaves normally.
+  function onAbort() {
+    leave();
+  }
+  callerSignal?.addEventListener("abort", onAbort, { once: true });
+  return { leave };
 }
 
-export function setInFlightRead(baseDir: string, keyId: string, read: Promise<MemoryFile[]>): void {
-  inFlightReadsByKey.set(composeKey(baseDir, keyId), read);
+/**
+ * Attach to an existing scan for (baseDir, keyId), or `undefined` when none is in
+ * flight. The caller MUST `leave()` once it stops awaiting the returned promise.
+ */
+export function attachInFlightReader(
+  baseDir: string,
+  keyId = "",
+  callerSignal?: AbortSignal,
+): { read: Promise<MemoryFile[]>; waiter: CoalescedScanWaiter } | undefined {
+  const entry = inFlightReadsByKey.get(composeKey(baseDir, keyId));
+  if (entry === undefined) return undefined;
+  entry.waiters += 1;
+  return { read: entry.read, waiter: trackWaiter(entry, callerSignal) };
+}
+
+/** Start a cancellable coalesced scan as its first waiter. */
+export function beginCoalescedScan(
+  baseDir: string,
+  keyId: string,
+  callerSignal?: AbortSignal,
+): CoalescedScan {
+  const controller = new AbortController();
+  let waiter: CoalescedScanWaiter | undefined;
+  return {
+    scanSignal: controller.signal,
+    arm(read: Promise<MemoryFile[]>): void {
+      // `waiters: 1` IS the starter; trackWaiter only builds its leave closure
+      // (attaching readers do their own increment).
+      const entry: InFlightEntry = {
+        read,
+        waiters: 1,
+        cancel: () => {
+          deleteInFlightRead(baseDir, keyId, read);
+          controller.abort();
+        },
+      };
+      inFlightReadsByKey.set(composeKey(baseDir, keyId), entry);
+      waiter = trackWaiter(entry, callerSignal);
+    },
+    leave(): void {
+      waiter?.leave();
+    },
+  };
+}
+
+/**
+ * Register a scan promise directly, with no cancellation attached.
+ *
+ * For callers that own a promise rather than a scan they can abort — tests that
+ * seed a stale in-flight read, and any future producer outside `beginCoalescedScan`.
+ * The entry has no `cancel`, so waiters leaving is a no-op: an externally-owned
+ * promise is not this module's to abort.
+ */
+export function setInFlightRead(
+  baseDir: string,
+  keyId: string,
+  read: Promise<MemoryFile[]>,
+): void {
+  inFlightReadsByKey.set(composeKey(baseDir, keyId), { read, waiters: 1 });
 }
 
 /**
@@ -41,7 +154,7 @@ export function deleteInFlightRead(
   expected?: Promise<MemoryFile[]>,
 ): void {
   const key = composeKey(baseDir, keyId);
-  if (expected === undefined || inFlightReadsByKey.get(key) === expected) {
+  if (expected === undefined || inFlightReadsByKey.get(key)?.read === expected) {
     inFlightReadsByKey.delete(key);
   }
 }

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

@@ -4414,7 +4414,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";
@@ -1872,10 +1873,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 +3971,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/storage/entity-store.ts

@@ -12,6 +12,7 @@
 
 import { readdir, unlink } from "node:fs/promises";
 import path from "node:path";
+import { checkCorpusReadAbort, type CorpusReadOptions } from "../corpus-read-cancellation.js";
 import { normalizeEntityStructuredSection, sortStructuredSectionsBySchema } from "../entity-schema.js";
 import { withEntityCanonicalMutationLock } from "./entity-canonical-id-lock.js";
 import { log } from "../logger.js";
@@ -482,7 +483,8 @@ export class EntityStore {
    * Read all entity files and return lightweight EntityFile objects.
    * Parsing is fast (~50-100ms for ~1,800 files) since entity files are small.
    */
-  async readAllEntityFiles(): Promise<EntityFile[]> {
+  async readAllEntityFiles(options?: CorpusReadOptions): Promise<EntityFile[]> {
+    checkCorpusReadAbort(options);
     const currentVersion = this.deps.getMemoryStatusVersion();
     const cacheKey = [
       this.deps.getEntityCacheSecureStoreKey(),
@@ -503,6 +505,9 @@ export class EntityStore {
       const BATCH_SIZE = 100;
       const entities: EntityFile[] = [];
       for (let i = 0; i < mdFiles.length; i += BATCH_SIZE) {
+        // Per batch, so an abandoned caller stops within one batch of I/O instead
+        // of reading every entity file for a result nobody awaits (issue #2307).
+        checkCorpusReadAbort(options);
         const batch = mdFiles.slice(i, i + BATCH_SIZE);
         const results = await Promise.all(
           batch.map(async (entry) => {
@@ -519,7 +524,9 @@ export class EntityStore {
           if (content !== null) entities.push(parseEntityFile(content, this.deps.entitySchemas));
         }
       }
-
+      // A signal that fired during the last batch's await would otherwise publish
+      // and return as if uncancelled (issue #2307 review).
+      checkCorpusReadAbort(options);
       setCachedEntities(this.deps.baseDir, entities, currentVersion, cacheKey);
       return entities;
     } catch (err) {