@remnic/core 10.0.6 → 10.0.8

package/dist/who-knows-cli.js

@@ -4,14 +4,15 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-FC6RCOIU.js";
-import "./chunk-XQSJXNWC.js";
-import "./chunk-37HCPM56.js";
-import "./chunk-46WM6JX2.js";
+} from "./chunk-KRIEQCKE.js";
+import "./chunk-3ENX2RB4.js";
+import "./chunk-WJLGUY27.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-LZKOVXMX.js";
 import "./chunk-V4JZCTMK.js";
-import "./chunk-RSMIRLKM.js";
-import "./chunk-U6OXJQEH.js";
+import "./chunk-7UX44C4N.js";
+import "./chunk-MB5EJ2CT.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-T3FMRLWQ.js";
 import "./chunk-7VO6E5UD.js";
 import "./chunk-5BUCKFRE.js";
@@ -19,7 +20,6 @@ import "./chunk-S7LWX2PQ.js";
 import "./chunk-T2YX56QI.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
@@ -28,12 +28,12 @@ import "./chunk-S2V7RUCL.js";
 import "./chunk-X3724WL4.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
-import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
+import "./chunk-DM2T26WE.js";
 import "./chunk-FF6N7BXC.js";
 import "./chunk-2DT7PIDZ.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-EIFYYHAF.js";
+import "./chunk-YYO447A7.js";
 import "./chunk-ZIKENA2C.js";
 import "./chunk-3OUGSOJP.js";
 import "./chunk-SCU65EZI.js";
@@ -41,20 +41,20 @@ import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
 import "./chunk-3WU7XOFN.js";
 import "./chunk-6MKLMEBE.js";
-import "./chunk-W5XWHTDO.js";
+import "./chunk-QZZPUREO.js";
 import "./chunk-M5GVCJSJ.js";
 import "./chunk-RBOJCG4T.js";
-import "./chunk-R7QY5ZVB.js";
+import "./chunk-4NDWE44P.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-7CT3AI52.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-AJ6ORARY.js";
-import "./chunk-IUM3VSHI.js";
+import "./chunk-DGRMWDQY.js";
 import "./chunk-G26YNEOC.js";
-import "./chunk-IM2GO42H.js";
-import "./chunk-TPSLVZHS.js";
 import "./chunk-SIGAGKNE.js";
+import "./chunk-IUM3VSHI.js";
+import "./chunk-WVHRNAXL.js";
+import "./chunk-TPSLVZHS.js";
 import "./chunk-23G5P7TA.js";
 import "./chunk-C64XATK7.js";
 import "./chunk-42JKGUFJ.js";
@@ -72,30 +72,31 @@ import "./chunk-PJKTFXE2.js";
 import "./chunk-W5BIQOAJ.js";
 import "./chunk-QWWMS4AE.js";
 import "./chunk-YBA52OKG.js";
-import "./chunk-5AYUHSAU.js";
+import "./chunk-OFCHT2TN.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-PO7NXNGC.js";
+import "./chunk-VFTK5WKI.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
 import "./chunk-L272A5QW.js";
-import "./chunk-XVC7JU2N.js";
+import "./chunk-FQD2KPQH.js";
 import "./chunk-ZA53AZND.js";
 import "./chunk-7RJUVTVF.js";
 import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
 import "./chunk-PWPIERBM.js";
 import "./chunk-C7HJ3NEI.js";
-import "./chunk-N4PYB235.js";
+import "./chunk-KI6UOSNR.js";
 import "./chunk-BTNNL7ZW.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
-import "./chunk-FFAZ2XFU.js";
+import "./chunk-EHRE7ZG3.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VUFL7X3H.js";
 import "./chunk-2EMROIXS.js";
+import "./chunk-7LEQREP2.js";
 import "./chunk-ZEFVK7XC.js";
 import "./chunk-6KH5NLQS.js";
 import "./chunk-P2QRMMVQ.js";

package/dist/who-knows.js

@@ -9,13 +9,14 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-XQSJXNWC.js";
-import "./chunk-37HCPM56.js";
-import "./chunk-46WM6JX2.js";
+} from "./chunk-3ENX2RB4.js";
+import "./chunk-WJLGUY27.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-LZKOVXMX.js";
 import "./chunk-V4JZCTMK.js";
-import "./chunk-RSMIRLKM.js";
-import "./chunk-U6OXJQEH.js";
+import "./chunk-7UX44C4N.js";
+import "./chunk-MB5EJ2CT.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-T3FMRLWQ.js";
 import "./chunk-7VO6E5UD.js";
 import "./chunk-5BUCKFRE.js";
@@ -23,7 +24,6 @@ import "./chunk-S7LWX2PQ.js";
 import "./chunk-T2YX56QI.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
@@ -32,12 +32,12 @@ import "./chunk-S2V7RUCL.js";
 import "./chunk-X3724WL4.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
-import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
+import "./chunk-DM2T26WE.js";
 import "./chunk-FF6N7BXC.js";
 import "./chunk-2DT7PIDZ.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-EIFYYHAF.js";
+import "./chunk-YYO447A7.js";
 import "./chunk-ZIKENA2C.js";
 import "./chunk-3OUGSOJP.js";
 import "./chunk-SCU65EZI.js";
@@ -45,20 +45,20 @@ import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
 import "./chunk-3WU7XOFN.js";
 import "./chunk-6MKLMEBE.js";
-import "./chunk-W5XWHTDO.js";
+import "./chunk-QZZPUREO.js";
 import "./chunk-M5GVCJSJ.js";
 import "./chunk-RBOJCG4T.js";
-import "./chunk-R7QY5ZVB.js";
+import "./chunk-4NDWE44P.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-7CT3AI52.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-AJ6ORARY.js";
-import "./chunk-IUM3VSHI.js";
+import "./chunk-DGRMWDQY.js";
 import "./chunk-G26YNEOC.js";
-import "./chunk-IM2GO42H.js";
-import "./chunk-TPSLVZHS.js";
 import "./chunk-SIGAGKNE.js";
+import "./chunk-IUM3VSHI.js";
+import "./chunk-WVHRNAXL.js";
+import "./chunk-TPSLVZHS.js";
 import "./chunk-23G5P7TA.js";
 import "./chunk-C64XATK7.js";
 import "./chunk-42JKGUFJ.js";
@@ -76,30 +76,31 @@ import "./chunk-PJKTFXE2.js";
 import "./chunk-W5BIQOAJ.js";
 import "./chunk-QWWMS4AE.js";
 import "./chunk-YBA52OKG.js";
-import "./chunk-5AYUHSAU.js";
+import "./chunk-OFCHT2TN.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-PO7NXNGC.js";
+import "./chunk-VFTK5WKI.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
 import "./chunk-L272A5QW.js";
-import "./chunk-XVC7JU2N.js";
+import "./chunk-FQD2KPQH.js";
 import "./chunk-ZA53AZND.js";
 import "./chunk-7RJUVTVF.js";
 import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
 import "./chunk-PWPIERBM.js";
 import "./chunk-C7HJ3NEI.js";
-import "./chunk-N4PYB235.js";
+import "./chunk-KI6UOSNR.js";
 import "./chunk-BTNNL7ZW.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
-import "./chunk-FFAZ2XFU.js";
+import "./chunk-EHRE7ZG3.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VUFL7X3H.js";
 import "./chunk-2EMROIXS.js";
+import "./chunk-7LEQREP2.js";
 import "./chunk-ZEFVK7XC.js";
 import "./chunk-6KH5NLQS.js";
 import "./chunk-P2QRMMVQ.js";

package/dist/write-envelope.js

@@ -12,16 +12,17 @@ import {
   isMemoryCategory,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-5AYUHSAU.js";
+} from "./chunk-OFCHT2TN.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-PO7NXNGC.js";
-import "./chunk-N4PYB235.js";
+import "./chunk-VFTK5WKI.js";
+import "./chunk-KI6UOSNR.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
-import "./chunk-FFAZ2XFU.js";
+import "./chunk-EHRE7ZG3.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-7LEQREP2.js";
 import "./chunk-MAAL6OZV.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-VS2IYZRU.js";

package/package.json

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

package/src/access-idempotency.ts

@@ -1,6 +1,7 @@
 import { mkdir, open, readFile, rename, stat, unlink, utimes, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
+import { sleep } from "./utils/sleep.js";
 
 type AccessIdempotencyEntry = {
   recordedAt: string;
@@ -359,7 +360,3 @@ async function unlinkStaleLockIfStillOwned(options: {
   await unlink(options.lockPath);
   return true;
 }
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/harmonic-retrieval.ts

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { existsSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import { listJsonFilesStrict, readJsonFile } from "./json-store.js";
 import { throwIfAborted } from "./abort-error.js";
@@ -22,31 +21,11 @@ import { readProjectedMemoryStates } from "./memory-projection-batch.js";
 import { SecureStoreLockedError } from "./secure-store/secure-fs.js";
 import { StorageManager } from "./storage.js";
 import { RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
-import { isPathInsideStorageRoot } from "./storage-paths.js";
+import { readHarmonicSourceMemory, readUnresolvedHarmonicSources } from "./harmonic-source-lookup.js";
 
 
 type SourceMemoryMap = Map<string, MemoryFile>;
 
-// `rootReal` set: a direct probe, which skips the corpus walk's symlink
-// hardening, so the resolved file must stay inside the memory root. Null: the
-// path came from the contained corpus walk and is already trusted.
-async function readMemoryFile(
-  storage: StorageManager,
-  rootReal: string | null,
-  filePath: string,
-  abortSignal?: AbortSignal,
-): Promise<MemoryFile | null> {
-  throwIfAborted(abortSignal, "harmonic retrieval aborted");
-  if (!existsSync(filePath)) return null;
-  try {
-    if (rootReal !== null && !isPathInsideStorageRoot(rootReal, await realpath(filePath))) return null;
-    return await storage.readMemoryByPath(filePath);
-  } catch (err) {
-    throwIfAborted(abortSignal, "harmonic retrieval aborted");
-    if (err instanceof SecureStoreLockedError) throw err;
-    return null;
-  }
-}
 
 // An index older than this is treated as unusable: the date window needed to
 // cover "created since the last rebuild" would stop being cheap.
@@ -61,13 +40,6 @@ function utcDaysSince(rebuiltMs: number, nowMs: number): string[] {
   return days;
 }
 
-// Source ids confirmed absent by a corpus path walk. A node only references a
-// source after the source file exists, so a confirmed absence stays true unless
-// the file is restored later; the short TTL bounds that. Without this, one
-// dangling id (a hard-deleted fact) would force a walk on every recall.
-const ABSENT_SOURCE_TTL_MS = 10 * 60_000;
-const ABSENT_SOURCE_MAX_ENTRIES = 4096;
-const absentSourceIds = new Map<string, number>(); // `${memoryDir}\0${id}` -> expiry ms
 
 // Memories the projection has no row for were written after its last rebuild, so
 // their dated directory is normally one of `days`. Hot and cold tiers are probed
@@ -84,16 +56,7 @@ function unprojectedCandidatePaths(memoryDir: string, id: string, days: string[]
   return paths;
 }
 
-/**
- * Resolve only the source ids the abstraction nodes reference. Returns null when
- * the projection is absent, unreadable, too old, or not known to cover every
- * active memory (a scoped or pre-`complete` rebuild), so the caller keeps the
- * full-corpus scan. Every file is read from disk, so status, tags and validity
- * are current; the index only says where to look. An id the cheap probes cannot
- * place (an import filed under an old date, a tier root outside the memory dir)
- * is looked up by one contained path-only walk, never a frontmatter parse of the
- * corpus.
- */
+/** Resolve indexed sources first, then use the durable unresolved-id path cache. */
 async function readIndexedSourceMemories(options: {
   memoryDir: string;
   abortSignal?: AbortSignal;
@@ -103,7 +66,7 @@ async function readIndexedSourceMemories(options: {
   // The ids go to SQL as bound parameters, so any id the projection holds is safe to look up.
   const batch = readProjectedMemoryStates(options.memoryDir, options.sourceMemoryIds);
   const rebuiltMs = Date.parse(batch?.rebuiltAt ?? "");
-  if (!batch?.complete || !Number.isFinite(rebuiltMs) || options.nowMs - rebuiltMs > INDEX_MAX_AGE_MS) return null;
+  if (!batch?.complete || !batch.rebuiltAt || !Number.isFinite(rebuiltMs) || options.nowMs - rebuiltMs > INDEX_MAX_AGE_MS) return null;
   const rootReal = await realpath(options.memoryDir).catch(() => null);
   if (rootReal === null) return null;
 
@@ -120,42 +83,27 @@ async function readIndexedSourceMemories(options: {
     } catch {
       safeId = false;
     }
-    // An unprojected id that is not a single path segment cannot be probed or
-    // matched by filename, and the scan keys sources by frontmatter id, so only
-    // the scan can place it. Rare (legacy/imported ids); worst case is the old cost.
-    if (!state && !safeId) return null;
     // state.path was containment-checked by the projection reader.
     const candidates = state
       ? [state.path, path.join(options.memoryDir, "cold", state.pathRel)]
-      : unprojectedCandidatePaths(options.memoryDir, id, days);
+      : safeId ? unprojectedCandidatePaths(options.memoryDir, id, days) : [];
     let found = false;
     for (const candidate of candidates) {
-      const memory = await readMemoryFile(storage, rootReal, candidate, options.abortSignal);
+      const memory = await readHarmonicSourceMemory(storage, rootReal, candidate, options.abortSignal);
       if (memory?.frontmatter.id !== id) continue;
       sourceMemories.set(id, memory);
       found = true;
       break;
     }
-    const absentKey = `${options.memoryDir}\0${id}`;
-    if (!found && safeId && (absentSourceIds.get(absentKey) ?? 0) <= options.nowMs) pending.push(id);
+    if (!found) pending.push(id);
   }
   if (pending.length === 0) return sourceMemories;
 
-  const wanted = new Set(pending);
-  const walked = [
-    ...(await storage.collectActiveMemoryPaths({ abortSignal: options.abortSignal })),
-    ...(await storage.collectColdMemoryPaths({ abortSignal: options.abortSignal })),
-  ];
-  for (const filePath of walked) {
-    throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
-    if (!wanted.has(path.basename(filePath, ".md"))) continue;
-    const memory = await readMemoryFile(storage, null, filePath, options.abortSignal);
-    if (memory && wanted.has(memory.frontmatter.id)) sourceMemories.set(memory.frontmatter.id, memory);
-  }
-  if (absentSourceIds.size > ABSENT_SOURCE_MAX_ENTRIES) absentSourceIds.clear();
-  for (const id of pending) {
-    if (!sourceMemories.has(id)) absentSourceIds.set(`${options.memoryDir}\0${id}`, options.nowMs + ABSENT_SOURCE_TTL_MS);
-  }
+  const unresolved = await readUnresolvedHarmonicSources({
+    storage, rootReal, rebuiltAt: batch.rebuiltAt, sourceMemoryIds: pending,
+    nowMs: options.nowMs, abortSignal: options.abortSignal,
+  });
+  for (const [id, memory] of unresolved) sourceMemories.set(id, memory);
   return sourceMemories;
 }
 
@@ -168,7 +116,7 @@ async function readCorpusSourceMemories(options: {
     const storage = new StorageManager(options.memoryDir);
     const [hotMemories, coldMemories] = await Promise.all([
       storage.readAllMemories({ abortSignal: options.abortSignal }),
-      storage.readAllColdMemories(),
+      storage.readAllColdMemories({ abortSignal: options.abortSignal }),
     ]);
     for (const memory of [...hotMemories, ...coldMemories]) {
       throwIfAborted(options.abortSignal, "harmonic retrieval aborted");

package/src/harmonic-source-lookup.test.ts

@@ -0,0 +1,178 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import { recordAbstractionNode } from "./abstraction-nodes.js";
+import { readProjectedHarmonicGraph } from "./harmonic-retrieval.js";
+import { rebuildMemoryProjection } from "./maintenance/rebuild-memory-projection.js";
+import { StorageManager } from "./storage.js";
+import { readUnresolvedHarmonicSources } from "./harmonic-source-lookup.js";
+import { bumpMemoryCorpusVersionForDir } from "./memory-corpus-version.js";
+
+async function seed(memoryDir: string) {
+  const storage = new StorageManager(memoryDir);
+  await storage.ensureDirectories();
+  const real = await storage.writeMemory("fact", "real harmonic source", { source: "test" });
+  await recordAbstractionNode({ memoryDir, node: {
+    schemaVersion: 1, nodeId: "source-lookup", recordedAt: new Date().toISOString(),
+    sessionKey: "agent:test", kind: "topic", abstractionLevel: "meso",
+    title: "source lookup", summary: "source lookup",
+    sourceMemoryIds: [real.id, "missing-source", "hot-import", "cold/import"],
+  } });
+  await rebuildMemoryProjection({ memoryDir, storage, dryRun: false });
+  return { storage, real };
+}
+
+async function importFile(memoryDir: string, tier: string, name: string, id: string) {
+  const dir = path.join(memoryDir, tier, "facts", "2000-01-01");
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, name),
+    `---\nid: ${id}\ncategory: fact\ncreated: 2000-01-01T00:00:00.000Z\nupdated: 2000-01-01T00:00:00.000Z\nsource: test\nconfidence: 0.8\nconfidenceTier: implied\ntags: []\n---\n\nImported ${id} body.\n`);
+}
+
+test("old-dated imports with non-id filenames resolve in both tiers without a corpus parse (#3188)", async (t) => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-harmonic-lookup-"));
+  try {
+    const { real } = await seed(memoryDir);
+    await importFile(memoryDir, "", "unrelated-hot-name.md", "hot-import");
+    await importFile(memoryDir, "cold", "unrelated-cold-name.md", "cold/import");
+    let scans = 0;
+    t.mock.method(StorageManager.prototype, "readAllMemories", async () => { scans += 1; return []; });
+    const graph = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.deepEqual(graph.nodes[0]?.sourceMemoryIds?.slice().sort(), [real.id, "hot-import", "cold/import"].sort());
+    assert.equal(scans, 0, "unprojected legacy ids must not force the full frontmatter corpus scan");
+  } finally {
+    t.mock.restoreAll();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("confirmed missing sources survive a fresh process without another path walk (#3188)", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-harmonic-durable-"));
+  try {
+    const { real } = await seed(memoryDir);
+    const graph = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.deepEqual(graph.nodes[0]?.sourceMemoryIds, [real.id]);
+    const script = `
+      import { StorageManager } from ${JSON.stringify(new URL("./storage.ts", import.meta.url).href)};
+      import { readProjectedHarmonicGraph } from ${JSON.stringify(new URL("./harmonic-retrieval.ts", import.meta.url).href)};
+      StorageManager.prototype.collectActiveMemoryPaths = async () => { throw new Error("unexpected hot walk after restart"); };
+      StorageManager.prototype.collectColdMemoryPaths = async () => { throw new Error("unexpected cold walk after restart"); };
+      StorageManager.prototype.readAllMemories = async () => { throw new Error("unexpected corpus scan after restart"); };
+      const graph = await readProjectedHarmonicGraph({ memoryDir: ${JSON.stringify(memoryDir)}, anchorsEnabled: false });
+      if (graph.nodes[0]?.sourceMemoryIds?.join() !== ${JSON.stringify(real.id)}) throw new Error("source lost after restart");
+    `;
+    await promisify(execFile)(process.execPath, ["--import", "tsx", "--input-type=module", "-e", script]);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+for (const invalidation of ["ttl", "rebuiltAt", "corpusVersion"]) {
+  test(`durable misses invalidate on ${invalidation} without losing an imported source (#3188)`, async () => {
+    const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-harmonic-epoch-"));
+    try {
+      const { storage } = await seed(memoryDir);
+      const nowMs = Date.now();
+      const options = {
+        storage, rootReal: await realpath(memoryDir), rebuiltAt: new Date(nowMs).toISOString(),
+        nowMs, sourceMemoryIds: ["restored-id"],
+      };
+      assert.equal((await readUnresolvedHarmonicSources(options)).size, 0);
+      await importFile(memoryDir, "", "not-the-source-id.md", "restored-id");
+      assert.equal((await readUnresolvedHarmonicSources(options)).size, 0, "the existing ten-minute miss window is preserved");
+      if (invalidation === "ttl") options.nowMs += 10 * 60_000;
+      if (invalidation === "rebuiltAt") options.rebuiltAt = new Date(nowMs + 1).toISOString();
+      if (invalidation === "corpusVersion") bumpMemoryCorpusVersionForDir(memoryDir);
+      const restored = await readUnresolvedHarmonicSources(options);
+      assert.equal(restored.get("restored-id")?.content.trim(), "Imported restored-id body.");
+    } finally {
+      await rm(memoryDir, { recursive: true, force: true });
+    }
+  });
+}
+
+test("harmonic cold walk receives cancellation and cannot publish a partial absence cache (#3188)", async (t) => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-harmonic-cancel-"));
+  try {
+    await seed(memoryDir);
+    await importFile(memoryDir, "cold", "cold-import.md", "cold/import");
+    const controller = new AbortController();
+    const original = StorageManager.prototype.collectColdMemoryPaths;
+    t.mock.method(StorageManager.prototype, "collectColdMemoryPaths", function (
+      this: StorageManager, options?: Parameters<StorageManager["collectColdMemoryPaths"]>[0],
+    ) {
+      assert.equal(options?.abortSignal, controller.signal);
+      controller.abort();
+      return original.call(this, options);
+    });
+    await assert.rejects(
+      () => readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false, abortSignal: controller.signal }),
+      { name: "AbortError" },
+    );
+    await assert.rejects(() => readFile(path.join(memoryDir, "state/harmonic-source-paths.json")), { code: "ENOENT" });
+    t.mock.restoreAll();
+    const graph = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.equal(graph.nodes[0]?.sourceMemoryIds?.includes("cold/import"), true);
+  } finally {
+    t.mock.restoreAll();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("an unreadable/unwritable path cache never suppresses an imported source (#3188)", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-harmonic-cache-errors-"));
+  try {
+    await seed(memoryDir);
+    await importFile(memoryDir, "", "not-id.md", "hot-import");
+    const cachePath = path.join(memoryDir, "state/harmonic-source-paths.json");
+    await mkdir(cachePath);
+    const graph = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.equal(graph.nodes[0]?.sourceMemoryIds?.includes("hot-import"), true);
+    await rm(cachePath, { recursive: true });
+    await writeFile(cachePath, "{broken");
+    const recovered = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.equal(recovered.nodes[0]?.sourceMemoryIds?.includes("hot-import"), true);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("an unresolved opaque id keeps the old scan candidate set for an edited projected file (#3188)", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-harmonic-opaque-"));
+  try {
+    const { storage, real } = await seed(memoryDir);
+    const memory = await storage.getMemoryById(real.id);
+    assert.ok(memory);
+    await writeFile(memory.path,
+      `---\nid: cold/import\ncategory: fact\ncreated: 2000-01-01T00:00:00.000Z\nupdated: 2000-01-01T00:00:00.000Z\nsource: test\nconfidence: 0.8\nconfidenceTier: implied\ntags: []\n---\n\nEdited projected legacy source.\n`);
+    const graph = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.deepEqual(graph.nodes[0]?.sourceMemoryIds, ["cold/import"]);
+    assert.equal(graph.nodes[0]?.summary, "Edited projected legacy source.");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("cached import paths reread source status without another walk (#3188)", async (t) => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-harmonic-fresh-status-"));
+  try {
+    const { real } = await seed(memoryDir);
+    await importFile(memoryDir, "", "not-id.md", "hot-import");
+    const first = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.equal(first.nodes[0]?.sourceMemoryIds?.includes("hot-import"), true);
+    const filePath = path.join(memoryDir, "facts/2000-01-01/not-id.md");
+    await writeFile(filePath, (await readFile(filePath, "utf8")).replace("category: fact", "category: fact\nstatus: quarantined"));
+    t.mock.method(StorageManager.prototype, "collectActiveMemoryPaths", async () => { throw new Error("unexpected hot walk"); });
+    t.mock.method(StorageManager.prototype, "collectColdMemoryPaths", async () => { throw new Error("unexpected cold walk"); });
+    t.mock.method(StorageManager.prototype, "readAllMemories", async () => { throw new Error("unexpected corpus parse"); });
+    const second = await readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: false });
+    assert.deepEqual(second.nodes[0]?.sourceMemoryIds, [real.id]);
+  } finally {
+    t.mock.restoreAll();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});