@remnic/core 10.0.6 → 10.0.8

package/dist/{chunk-VFUEZZBS.js → chunk-5JMI26Q7.js}

@@ -1,3 +1,7 @@
+import {
+  sleep
+} from "./chunk-7LEQREP2.js";
+
 // src/access-idempotency.ts
 import { mkdir, open, readFile, rename, stat, unlink, utimes, writeFile } from "fs/promises";
 import path from "path";
@@ -299,13 +303,10 @@ async function unlinkStaleLockIfStillOwned(options) {
   await unlink(options.lockPath);
   return true;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 
 export {
   hashAccessIdempotencyPayload,
   setAccessIdempotencyTestHooks,
   AccessIdempotencyStore
 };
-//# sourceMappingURL=chunk-VFUEZZBS.js.map
+//# sourceMappingURL=chunk-5JMI26Q7.js.map

package/dist/chunk-5JMI26Q7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/access-idempotency.ts"],"sourcesContent":["import { mkdir, open, readFile, rename, stat, unlink, utimes, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { sleep } from \"./utils/sleep.js\";\n\ntype AccessIdempotencyEntry = {\n  recordedAt: string;\n  requestHash: string;\n  response: unknown;\n};\n\ntype AccessIdempotencyTestHooks = {\n  beforeFlushWrite?: () => Promise<void> | void;\n  lockTimeoutMs?: number;\n  staleLockMs?: number;\n  lockHeartbeatMs?: number;\n  beforeLockOwnerWrite?: (lockPath: string, ownerToken: string) => Promise<void> | void;\n  beforeStaleLockUnlink?: () => Promise<void> | void;\n};\n\nlet testHooks: AccessIdempotencyTestHooks | null = null;\n\nfunction stableStringify(value: unknown): string {\n  return JSON.stringify(value, (_key, candidate) => {\n    if (!candidate || typeof candidate !== \"object\" || Array.isArray(candidate)) {\n      return candidate;\n    }\n    return Object.keys(candidate)\n      .sort()\n      .reduce<Record<string, unknown>>((acc, key) => {\n        acc[key] = (candidate as Record<string, unknown>)[key];\n        return acc;\n      }, {});\n  });\n}\n\nexport function hashAccessIdempotencyPayload(payload: unknown): string {\n  return createHash(\"sha256\").update(stableStringify(payload)).digest(\"hex\");\n}\n\nexport function setAccessIdempotencyTestHooks(hooks: AccessIdempotencyTestHooks | null): void {\n  testHooks = hooks;\n}\n\nexport class AccessIdempotencyStore {\n  private readonly statePath: string;\n  private readonly lockPath: string;\n  private readonly keyLockDir: string;\n  private loadedMtimeMs = 0;\n  private state: Record<string, AccessIdempotencyEntry> = {};\n  private writeQueue: Promise<void> = Promise.resolve();\n\n  constructor(memoryDir: string) {\n    this.statePath = path.join(memoryDir, \"state\", \"access-idempotency.json\");\n    this.lockPath = `${this.statePath}.lock`;\n    this.keyLockDir = path.join(memoryDir, \"state\", \"access-idempotency-locks\");\n  }\n\n  async get(key: string, requestHash: string): Promise<{ response?: unknown; conflict: boolean }> {\n    await this.writeQueue.catch(() => {});\n    await this.reload({ forceRefresh: true });\n    const entry = this.state[key];\n    if (!entry) return { conflict: false };\n    if (entry.requestHash !== requestHash) {\n      return { conflict: true };\n    }\n    return {\n      conflict: false,\n      response: JSON.parse(JSON.stringify(entry.response)),\n    };\n  }\n\n  async put(key: string, requestHash: string, response: unknown): Promise<void> {\n    await this.withWriteQueue(async () => {\n      await this.reload({ forceRefresh: true });\n      this.state[key] = {\n        recordedAt: new Date().toISOString(),\n        requestHash,\n        response: JSON.parse(JSON.stringify(response)),\n      };\n      await this.prune();\n      await this.flush();\n    });\n  }\n\n  async withKeyLock<T>(key: string, callback: () => Promise<T>): Promise<T> {\n    const keyHash = createHash(\"sha256\").update(key).digest(\"hex\");\n    const keyLockPath = path.join(this.keyLockDir, `${keyHash}.lock`);\n    return this.withExclusiveFileLock(keyLockPath, callback);\n  }\n\n  private async reload(options: { forceRefresh?: boolean } = {}): Promise<void> {\n    if (options.forceRefresh === true) {\n      try {\n        const fileStat = await stat(this.statePath);\n        if (fileStat.mtimeMs < this.loadedMtimeMs) {\n          return;\n        }\n      } catch {\n        this.state = {};\n        this.loadedMtimeMs = 0;\n        return;\n      }\n    }\n    try {\n      const raw = await readFile(this.statePath, \"utf-8\");\n      const parsed = JSON.parse(raw) as Record<string, AccessIdempotencyEntry>;\n      if (parsed && typeof parsed === \"object\") {\n        this.state = parsed;\n        this.loadedMtimeMs = await this.readMtimeMs();\n        return;\n      }\n    } catch {\n      // Missing or malformed state should fail open to an empty store.\n    }\n    this.state = {};\n    this.loadedMtimeMs = 0;\n  }\n\n  private async prune(): Promise<void> {\n    const entries = Object.entries(this.state);\n    if (entries.length <= 512) return;\n    entries\n      .sort((left, right) => right[1].recordedAt.localeCompare(left[1].recordedAt))\n      .slice(512)\n      .forEach(([key]) => {\n        delete this.state[key];\n      });\n  }\n\n  private async flush(): Promise<void> {\n    await mkdir(path.dirname(this.statePath), { recursive: true });\n    await this.withExclusiveFileLock(this.lockPath, async () => {\n      try {\n        const raw = await readFile(this.statePath, \"utf-8\");\n        const parsed = JSON.parse(raw) as Record<string, AccessIdempotencyEntry>;\n        if (parsed && typeof parsed === \"object\") {\n          this.state = {\n            ...parsed,\n            ...this.state,\n          };\n          await this.prune();\n        }\n      } catch {\n        // Fail open when there is no pre-existing shared state to merge.\n      }\n\n      await testHooks?.beforeFlushWrite?.();\n\n      const tempPath = `${this.statePath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;\n      try {\n        await writeFile(tempPath, JSON.stringify(this.state, null, 2), \"utf-8\");\n        await rename(tempPath, this.statePath);\n      } finally {\n        await unlink(tempPath).catch(() => undefined);\n      }\n      this.loadedMtimeMs = await this.readMtimeMs();\n    });\n  }\n\n  private async readMtimeMs(): Promise<number> {\n    try {\n      return (await stat(this.statePath)).mtimeMs;\n    } catch {\n      return 0;\n    }\n  }\n\n  private async withExclusiveFileLock<T>(lockPath: string, callback: () => Promise<T>): Promise<T> {\n    await mkdir(path.dirname(lockPath), { recursive: true });\n    const timeoutMs = testHooks?.lockTimeoutMs ?? 5_000;\n    const staleLockMs = testHooks?.staleLockMs ?? 30_000;\n    const lockHeartbeatMs = testHooks?.lockHeartbeatMs ?? Math.max(1_000, Math.floor(staleLockMs / 3));\n    const startedAt = Date.now();\n\n    while (true) {\n      const ownerToken = `${process.pid}:${randomUUID()}`;\n      try {\n        const handle = await open(lockPath, \"wx\");\n        try {\n          await testHooks?.beforeLockOwnerWrite?.(lockPath, ownerToken);\n          await handle.writeFile(ownerToken, \"utf-8\");\n        } catch (error) {\n          await handle.close().catch(() => undefined);\n          await unlink(lockPath).catch(() => undefined);\n          throw error;\n        }\n        let heartbeat: NodeJS.Timeout | null = null;\n        if (lockHeartbeatMs > 0) {\n          heartbeat = setInterval(() => {\n            void utimes(lockPath, new Date(), new Date()).catch(() => undefined);\n          }, lockHeartbeatMs);\n          heartbeat.unref?.();\n        }\n        try {\n          return await callback();\n        } finally {\n          if (heartbeat) {\n            clearInterval(heartbeat);\n          }\n          await handle.close().catch(() => undefined);\n          await unlinkLockIfOwner(lockPath, ownerToken, staleLockMs);\n        }\n      } catch (error) {\n        if (!isAlreadyExistsError(error)) throw error;\n        try {\n          const lockStat = await stat(lockPath);\n          const lockOwner = await readLockOwner(lockPath);\n          if (Date.now() - lockStat.mtimeMs > staleLockMs) {\n            await testHooks?.beforeStaleLockUnlink?.();\n            const removed = await unlinkStaleLockIfUnchanged({\n              lockPath,\n              observedOwner: lockOwner,\n              observedMtimeMs: lockStat.mtimeMs,\n              staleLockMs,\n            });\n            if (!removed) {\n              await sleep(10);\n            }\n            continue;\n          }\n        } catch {\n          continue;\n        }\n        if (Date.now() - startedAt > timeoutMs) {\n          throw new Error(\"timed out acquiring access idempotency lock\");\n        }\n        await sleep(10);\n      }\n    }\n  }\n\n  private async withWriteQueue<T>(callback: () => Promise<T>): Promise<T> {\n    const previous = this.writeQueue;\n    let release!: () => void;\n    this.writeQueue = new Promise<void>((resolve) => {\n      release = resolve;\n    });\n    await previous.catch(() => {});\n    try {\n      return await callback();\n    } finally {\n      release();\n    }\n  }\n}\n\nfunction isAlreadyExistsError(error: unknown): boolean {\n  return typeof error === \"object\" && error !== null && \"code\" in error && error.code === \"EEXIST\";\n}\n\nasync function readLockOwner(lockPath: string): Promise<string | null> {\n  try {\n    return await readFile(lockPath, \"utf-8\");\n  } catch {\n    return null;\n  }\n}\n\nasync function unlinkLockIfOwner(lockPath: string, ownerToken: string, staleLockMs: number): Promise<void> {\n  const reclaimHandle = await openStaleReclaimLock(`${lockPath}.reclaim`, staleLockMs);\n  if (!reclaimHandle) return;\n  try {\n    await reclaimHandle.writeFile(`${process.pid}:${Date.now()}`, \"utf-8\");\n    await unlinkLockIfOwnerWhileReclaimHeld(lockPath, ownerToken);\n  } finally {\n    await reclaimHandle.close().catch(() => undefined);\n    await unlink(`${lockPath}.reclaim`).catch(() => undefined);\n  }\n}\n\nasync function unlinkLockIfOwnerWhileReclaimHeld(lockPath: string, ownerToken: string): Promise<void> {\n  let handle: Awaited<ReturnType<typeof open>>;\n  try {\n    handle = await open(lockPath, \"r\");\n  } catch {\n    return;\n  }\n  try {\n    const openedStat = await handle.stat();\n    const currentOwner = await handle.readFile(\"utf-8\");\n    if (currentOwner !== ownerToken) return;\n    let currentStat: Awaited<ReturnType<typeof stat>>;\n    try {\n      currentStat = await stat(lockPath);\n    } catch {\n      return;\n    }\n    if (!isSameFileIdentity(openedStat, currentStat)) return;\n  } finally {\n    await handle.close().catch(() => undefined);\n  }\n  await unlink(lockPath).catch(() => undefined);\n}\n\nfunction isSameFileIdentity(left: Awaited<ReturnType<typeof stat>>, right: Awaited<ReturnType<typeof stat>>): boolean {\n  return left.dev === right.dev && left.ino === right.ino;\n}\n\nasync function unlinkStaleLockIfUnchanged(options: {\n  lockPath: string;\n  observedOwner: string | null;\n  observedMtimeMs: number;\n  staleLockMs: number;\n}): Promise<boolean> {\n  const reclaimPath = `${options.lockPath}.reclaim`;\n  const reclaimHandle = await openStaleReclaimLock(reclaimPath, options.staleLockMs);\n  if (!reclaimHandle) return false;\n  try {\n    await reclaimHandle.writeFile(`${process.pid}:${Date.now()}`, \"utf-8\");\n    return await unlinkStaleLockIfStillOwned(options);\n  } finally {\n    await reclaimHandle.close().catch(() => undefined);\n    await unlink(reclaimPath).catch(() => undefined);\n  }\n}\n\nasync function openStaleReclaimLock(\n  reclaimPath: string,\n  staleLockMs: number,\n): Promise<Awaited<ReturnType<typeof open>> | null> {\n  try {\n    return await open(reclaimPath, \"wx\");\n  } catch (error) {\n    if (!isAlreadyExistsError(error)) throw error;\n  }\n\n  try {\n    const reclaimStat = await stat(reclaimPath);\n    if (Date.now() - reclaimStat.mtimeMs <= staleLockMs) return null;\n    await unlink(reclaimPath);\n  } catch {\n    return null;\n  }\n\n  try {\n    return await open(reclaimPath, \"wx\");\n  } catch (error) {\n    if (isAlreadyExistsError(error)) return null;\n    throw error;\n  }\n}\n\nasync function unlinkStaleLockIfStillOwned(options: {\n  lockPath: string;\n  observedOwner: string | null;\n  observedMtimeMs: number;\n  staleLockMs: number;\n}): Promise<boolean> {\n  let currentStat: Awaited<ReturnType<typeof stat>>;\n  try {\n    currentStat = await stat(options.lockPath);\n  } catch {\n    return true;\n  }\n  if (currentStat.mtimeMs !== options.observedMtimeMs) return false;\n  if (Date.now() - currentStat.mtimeMs <= options.staleLockMs) return false;\n  const currentOwner = await readLockOwner(options.lockPath);\n  if (currentOwner !== options.observedOwner) return false;\n  await unlink(options.lockPath);\n  return true;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-KSUOM3YU.js → chunk-5NOPZYNI.js}

@@ -3,7 +3,7 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-QMFKW4OU.js";
+} from "./chunk-L3Z4NXDO.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-CMTINOFS.js";
 import {
   summarizeCorpusAndReplica
-} from "./chunk-KQI2PKYP.js";
+} from "./chunk-JTUKDLAD.js";
 import {
   readJudgeVerdictStats
 } from "./chunk-OZKOPQCM.js";
@@ -32,32 +32,32 @@ import {
 } from "./chunk-2DQ2XREU.js";
 import {
   runConsolidationProvenanceCheck
-} from "./chunk-MULNBSPP.js";
+} from "./chunk-HT2C4EXO.js";
 import {
   reportBufferSurpriseDistribution
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-5BPXMAUP.js";
+} from "./chunk-VUQDJ3JB.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-7LYRFI5A.js";
+} from "./chunk-5Q4NQNW7.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-4K2H4KTR.js";
+} from "./chunk-AV46CT77.js";
 import {
   listNamespaces
-} from "./chunk-SNXBXYUE.js";
+} from "./chunk-GDI64ITR.js";
 import {
   analyzeGraphHealth
-} from "./chunk-2U3R3DDH.js";
+} from "./chunk-BTJ6CAIA.js";
 import {
   summarizeExtractionLiveness
 } from "./chunk-AWD36R4D.js";
 import {
   StorageManager
-} from "./chunk-37HCPM56.js";
+} from "./chunk-WJLGUY27.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
@@ -1069,7 +1069,7 @@ async function summarizeBufferSurpriseDistribution(storage, config) {
   }
 }
 async function summarizeGraphEdgeDecayStatus(config) {
-  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-PVKDKLQK.js");
+  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-CZ3SYLM4.js");
   const { graphEdgeDecayEnabled } = config;
   const enabled = graphEdgeDecayEnabled === true;
   if (!enabled) {
@@ -1683,4 +1683,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-KSUOM3YU.js.map
+//# sourceMappingURL=chunk-5NOPZYNI.js.map

package/dist/{chunk-7LYRFI5A.js → chunk-5Q4NQNW7.js}

@@ -1,6 +1,6 @@
 import {
   resolveCorpusNamespaceRoots
-} from "./chunk-ANZXWOYD.js";
+} from "./chunk-5FNVK7MW.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-IG747LRN.js";
@@ -200,4 +200,4 @@ async function readAggregateExtractionWatermark(options) {
 export {
   readAggregateExtractionWatermark
 };
-//# sourceMappingURL=chunk-7LYRFI5A.js.map
+//# sourceMappingURL=chunk-5Q4NQNW7.js.map

package/dist/chunk-5VC7J76U.js

@@ -0,0 +1,134 @@
+import {
+  readProjectedMemoryPaths
+} from "./chunk-AZEZSQ5R.js";
+import {
+  throwIfAborted
+} from "./chunk-BTTPKDIL.js";
+import {
+  isRecord
+} from "./chunk-A2IYSXDQ.js";
+import {
+  readJsonFile,
+  writeJsonFileAtomic
+} from "./chunk-B6O2YLUR.js";
+import {
+  isPathInsideStorageRoot,
+  isSafeLegacyPathSegment
+} from "./chunk-LDPPTPO5.js";
+import {
+  SecureStoreLockedError
+} from "./chunk-MAAL6OZV.js";
+import {
+  RECALL_FALLBACK_DIRS
+} from "./chunk-VS2IYZRU.js";
+
+// src/harmonic-source-lookup.ts
+import path from "path";
+import { existsSync } from "fs";
+import { mkdir, realpath } from "fs/promises";
+var LOOKUP_TTL_MS = 10 * 6e4;
+var MAX_CACHE_ENTRIES = 4096;
+async function readHarmonicSourceMemory(storage, rootReal, filePath, abortSignal) {
+  throwIfAborted(abortSignal, "harmonic retrieval aborted");
+  if (!existsSync(filePath)) return null;
+  try {
+    if (!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;
+  }
+}
+function isCorpusPath(memoryDir, filePath) {
+  if (!isPathInsideStorageRoot(memoryDir, filePath)) return false;
+  const [dir] = path.relative(memoryDir, filePath).split(path.sep);
+  return dir === "cold" || RECALL_FALLBACK_DIRS.includes(dir);
+}
+async function readPathCache(filePath, rebuiltAt, corpusVersion, nowMs) {
+  try {
+    const raw = await readJsonFile(filePath);
+    if (!isRecord(raw) || raw.rebuiltAt !== rebuiltAt || raw.corpusVersion !== corpusVersion || !Array.isArray(raw.entries)) return /* @__PURE__ */ new Map();
+    const entries = /* @__PURE__ */ new Map();
+    for (const row of raw.entries) {
+      if (!Array.isArray(row) || row.length !== 3) continue;
+      const [id, storedPath, expiresAt] = row;
+      if (typeof id !== "string" || storedPath !== null && typeof storedPath !== "string") continue;
+      if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt) || expiresAt <= nowMs || expiresAt > nowMs + LOOKUP_TTL_MS) continue;
+      entries.set(id, { path: storedPath, expiresAt });
+    }
+    return entries;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function readUnresolvedHarmonicSources(options) {
+  const { storage, rootReal, rebuiltAt, nowMs, abortSignal } = options;
+  throwIfAborted(abortSignal, "harmonic retrieval aborted");
+  const corpusVersion = storage.getCorpusScanVersion();
+  const stateDir = path.join(storage.dir, "state");
+  const cachePath = path.join(stateDir, "harmonic-source-paths.json");
+  const stateReal = await realpath(stateDir).catch(() => null);
+  const safeCache = stateReal !== null && isPathInsideStorageRoot(rootReal, stateReal);
+  const cache = safeCache ? await readPathCache(cachePath, rebuiltAt, corpusVersion, nowMs) : /* @__PURE__ */ new Map();
+  const found = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  for (const id of options.sourceMemoryIds) {
+    throwIfAborted(abortSignal, "harmonic retrieval aborted");
+    const entry = cache.get(id);
+    if (entry?.path === null) continue;
+    if (entry?.path) {
+      const candidate = path.resolve(storage.dir, entry.path);
+      const memory = isCorpusPath(storage.dir, candidate) ? await readHarmonicSourceMemory(storage, rootReal, candidate, abortSignal) : null;
+      if (memory?.frontmatter.id === id) {
+        found.set(id, memory);
+        continue;
+      }
+    }
+    pending.add(id);
+  }
+  if (pending.size === 0) return found;
+  const inspectProjected = [...pending].some((id) => !isSafeLegacyPathSegment(id));
+  const projectedPaths = readProjectedMemoryPaths(storage.dir);
+  const walked = [
+    ...await storage.collectActiveMemoryPaths({ abortSignal, propagateReadErrors: true }),
+    ...await storage.collectColdMemoryPaths({ abortSignal, propagateReadErrors: true })
+  ];
+  for (const filePath of walked) {
+    throwIfAborted(abortSignal, "harmonic retrieval aborted");
+    if (!inspectProjected && !pending.has(path.basename(filePath, ".md")) && projectedPaths?.has(filePath)) continue;
+    const memory = await readHarmonicSourceMemory(storage, rootReal, filePath, abortSignal);
+    if (!memory) continue;
+    const id = memory.frontmatter.id;
+    if (pending.has(id)) {
+      found.set(id, memory);
+      cache.set(id, { path: path.relative(storage.dir, filePath), expiresAt: nowMs + LOOKUP_TTL_MS });
+    }
+  }
+  for (const id of pending) {
+    if (!found.has(id)) cache.set(id, { path: null, expiresAt: nowMs + LOOKUP_TTL_MS });
+  }
+  throwIfAborted(abortSignal, "harmonic retrieval aborted");
+  if (storage.getCorpusScanVersion() === corpusVersion) {
+    try {
+      await mkdir(stateDir, { recursive: true });
+      if (isPathInsideStorageRoot(rootReal, await realpath(stateDir))) {
+        throwIfAborted(abortSignal, "harmonic retrieval aborted");
+        await writeJsonFileAtomic(cachePath, {
+          rebuiltAt,
+          corpusVersion,
+          entries: [...cache].slice(-MAX_CACHE_ENTRIES).map(([id, entry]) => [id, entry.path, entry.expiresAt])
+        });
+      }
+    } catch {
+      throwIfAborted(abortSignal, "harmonic retrieval aborted");
+    }
+  }
+  return found;
+}
+
+export {
+  readHarmonicSourceMemory,
+  readUnresolvedHarmonicSources
+};
+//# sourceMappingURL=chunk-5VC7J76U.js.map

package/dist/chunk-5VC7J76U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/harmonic-source-lookup.ts"],"sourcesContent":["import path from \"node:path\";\nimport { existsSync } from \"node:fs\";\nimport { mkdir, realpath } from \"node:fs/promises\";\nimport { throwIfAborted } from \"./abort-error.js\";\nimport { readJsonFile, writeJsonFileAtomic } from \"./json-store.js\";\nimport { readProjectedMemoryPaths } from \"./memory-projection-batch.js\";\nimport { SecureStoreLockedError } from \"./secure-store/secure-fs.js\";\nimport { isPathInsideStorageRoot, isSafeLegacyPathSegment } from \"./storage-paths.js\";\nimport { isRecord } from \"./store-contract.js\";\nimport type { StorageManager } from \"./storage.js\";\nimport type { MemoryFile } from \"./types.js\";\nimport { RECALL_FALLBACK_DIRS } from \"./utils/category-dir.js\";\n\nconst LOOKUP_TTL_MS = 10 * 60_000;\nconst MAX_CACHE_ENTRIES = 4096;\ntype PathEntry = { path: string | null; expiresAt: number };\n\n/** Direct and cached probes must retain the walk's realpath containment check. */\nexport async function readHarmonicSourceMemory(\n  storage: StorageManager,\n  rootReal: string,\n  filePath: string,\n  abortSignal?: AbortSignal,\n): Promise<MemoryFile | null> {\n  throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n  if (!existsSync(filePath)) return null;\n  try {\n    if (!isPathInsideStorageRoot(rootReal, await realpath(filePath))) return null;\n    return await storage.readMemoryByPath(filePath);\n  } catch (err) {\n    throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n    if (err instanceof SecureStoreLockedError) throw err;\n    return null;\n  }\n}\n\nfunction isCorpusPath(memoryDir: string, filePath: string): boolean {\n  if (!isPathInsideStorageRoot(memoryDir, filePath)) return false;\n  const [dir] = path.relative(memoryDir, filePath).split(path.sep);\n  return dir === \"cold\" || RECALL_FALLBACK_DIRS.includes(dir);\n}\n\n/** A cache miss is not authoritative: unreadable/invalid cache state keeps the walk. */\nasync function readPathCache(\n  filePath: string, rebuiltAt: string, corpusVersion: string, nowMs: number,\n): Promise<Map<string, PathEntry>> {\n  try {\n    const raw = await readJsonFile(filePath);\n    if (!isRecord(raw) || raw.rebuiltAt !== rebuiltAt || raw.corpusVersion !== corpusVersion || !Array.isArray(raw.entries)) return new Map();\n    const entries = new Map<string, PathEntry>();\n    for (const row of raw.entries) {\n      if (!Array.isArray(row) || row.length !== 3) continue;\n      const [id, storedPath, expiresAt] = row;\n      if (typeof id !== \"string\" || (storedPath !== null && typeof storedPath !== \"string\")) continue;\n      if (typeof expiresAt !== \"number\" || !Number.isFinite(expiresAt) || expiresAt <= nowMs || expiresAt > nowMs + LOOKUP_TTL_MS) continue;\n      entries.set(id, { path: storedPath, expiresAt });\n    }\n    return entries;\n  } catch {\n    return new Map();\n  }\n}\n\n/** Resolve only unresolved ids; persist paths/absence, never memory content. */\nexport async function readUnresolvedHarmonicSources(options: {\n  storage: StorageManager;\n  rootReal: string;\n  rebuiltAt: string;\n  sourceMemoryIds: string[];\n  nowMs: number;\n  abortSignal?: AbortSignal;\n}): Promise<Map<string, MemoryFile>> {\n  const { storage, rootReal, rebuiltAt, nowMs, abortSignal } = options;\n  throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n  const corpusVersion = storage.getCorpusScanVersion();\n  const stateDir = path.join(storage.dir, \"state\");\n  const cachePath = path.join(stateDir, \"harmonic-source-paths.json\");\n  const stateReal = await realpath(stateDir).catch(() => null);\n  const safeCache = stateReal !== null && isPathInsideStorageRoot(rootReal, stateReal);\n  const cache = safeCache ? await readPathCache(cachePath, rebuiltAt, corpusVersion, nowMs) : new Map<string, PathEntry>();\n  const found = new Map<string, MemoryFile>();\n  const pending = new Set<string>();\n  for (const id of options.sourceMemoryIds) {\n    throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n    const entry = cache.get(id);\n    if (entry?.path === null) continue;\n    if (entry?.path) {\n      const candidate = path.resolve(storage.dir, entry.path);\n      const memory = isCorpusPath(storage.dir, candidate)\n        ? await readHarmonicSourceMemory(storage, rootReal, candidate, abortSignal) : null;\n      if (memory?.frontmatter.id === id) {\n        found.set(id, memory);\n        continue;\n      }\n    }\n    pending.add(id);\n  }\n  if (pending.size === 0) return found;\n\n  // Opaque legacy ids previously used the full scan, including edited projected files.\n  const inspectProjected = [...pending].some((id) => !isSafeLegacyPathSegment(id));\n  const projectedPaths = readProjectedMemoryPaths(storage.dir);\n  const walked = [\n    ...(await storage.collectActiveMemoryPaths({ abortSignal, propagateReadErrors: true })),\n    ...(await storage.collectColdMemoryPaths({ abortSignal, propagateReadErrors: true })),\n  ];\n  for (const filePath of walked) {\n    throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n    // Existing projected files need no parse unless their filename names a wanted id.\n    // New/imported files must be keyed by frontmatter id, not their basename (#3188).\n    if (!inspectProjected && !pending.has(path.basename(filePath, \".md\")) && projectedPaths?.has(filePath)) continue;\n    const memory = await readHarmonicSourceMemory(storage, rootReal, filePath, abortSignal);\n    if (!memory) continue;\n    const id = memory.frontmatter.id;\n    if (pending.has(id)) {\n      found.set(id, memory);\n      cache.set(id, { path: path.relative(storage.dir, filePath), expiresAt: nowMs + LOOKUP_TTL_MS });\n    }\n  }\n  for (const id of pending) {\n    if (!found.has(id)) cache.set(id, { path: null, expiresAt: nowMs + LOOKUP_TTL_MS });\n  }\n  throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n  // A concurrent mutation must not publish absence for a different corpus epoch.\n  if (storage.getCorpusScanVersion() === corpusVersion) {\n    try {\n      await mkdir(stateDir, { recursive: true });\n      if (isPathInsideStorageRoot(rootReal, await realpath(stateDir))) {\n        throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n        // ponytail: atomic last-writer-wins cache; contention can repeat a walk, not lose sources.\n        await writeJsonFileAtomic(cachePath, {\n          rebuiltAt, corpusVersion,\n          entries: [...cache].slice(-MAX_CACHE_ENTRIES).map(([id, entry]) => [id, entry.path, entry.expiresAt]),\n        });\n      }\n    } catch {\n      throwIfAborted(abortSignal, \"harmonic retrieval aborted\");\n      // Cache publication is optional; resolved memories remain usable on a read-only store.\n    }\n  }\n  return found;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-L3PWXD73.js → chunk-6PHB45IU.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-5JMAGU26.js";
 import {
   runPostConsolidationMaterialize
-} from "./chunk-YJEUHGZZ.js";
+} from "./chunk-ZQYAE2C5.js";
 import {
   isSemanticConsolidationLlmOperator
 } from "./chunk-G7D6GZ5J.js";
@@ -220,4 +220,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-L3PWXD73.js.map
+//# sourceMappingURL=chunk-6PHB45IU.js.map

package/dist/{chunk-CHDGJJV6.js → chunk-6VAHJ2F6.js}

@@ -1,6 +1,6 @@
 import {
   readAllEdges
-} from "./chunk-2U3R3DDH.js";
+} from "./chunk-BTJ6CAIA.js";
 import {
   readEdgeConfidence
 } from "./chunk-2LSZVONP.js";
@@ -162,4 +162,4 @@ export {
   parseGraphSnapshotSince,
   buildGraphSnapshot
 };
-//# sourceMappingURL=chunk-CHDGJJV6.js.map
+//# sourceMappingURL=chunk-6VAHJ2F6.js.map

package/dist/{chunk-KQT4DRKF.js → chunk-76KHEHT2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-DTXN4NVD.js";
+} from "./chunk-NYVKLB2I.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-KQT4DRKF.js.map
+//# sourceMappingURL=chunk-76KHEHT2.js.map

package/dist/chunk-7LEQREP2.js

@@ -0,0 +1,9 @@
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  sleep
+};
+//# sourceMappingURL=chunk-7LEQREP2.js.map

package/dist/chunk-7LEQREP2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/sleep.ts"],"sourcesContent":["/** Wait without cancellation; keep the timer referenced so awaited polling can finish. */\nexport function sleep(ms: number): Promise<void> {\n  // Constructor form keeps this reachable utility compatible with ES2022 adapter type graphs.\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AACO,SAAS,MAAM,IAA2B;AAE/C,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD;","names":[]}

package/dist/{chunk-SWRN6U7Q.js → chunk-7O252IE6.js}

@@ -1,6 +1,6 @@
 import {
   runLocationSync
-} from "./chunk-DJMVSUPK.js";
+} from "./chunk-A6G7K273.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -58,4 +58,4 @@ export {
   LOCATION_SYNC_DEFAULT_INTERVAL_MS,
   startLocationAutoSync
 };
-//# sourceMappingURL=chunk-SWRN6U7Q.js.map
+//# sourceMappingURL=chunk-7O252IE6.js.map

package/dist/{chunk-U6HWKOGD.js → chunk-7OAIOE5P.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-A7AISUJI.js";
 import {
   deepRecallRequestSchema
-} from "./chunk-SIYZDT2V.js";
+} from "./chunk-CBP4HWCL.js";
 import {
   EngramAccessInputError
 } from "./chunk-3MUKQQ7A.js";
@@ -40,4 +40,4 @@ async function respondDeepRecall(req, res, respondJson, readJsonBody, service, s
 export {
   respondDeepRecall
 };
-//# sourceMappingURL=chunk-U6HWKOGD.js.map
+//# sourceMappingURL=chunk-7OAIOE5P.js.map

package/dist/{chunk-RSMIRLKM.js → chunk-7UX44C4N.js}

@@ -1,6 +1,6 @@
 import {
   createSearchBackend
-} from "./chunk-U6OXJQEH.js";
+} from "./chunk-MB5EJ2CT.js";
 import {
   namespaceIdentityToken,
   normalizeNamespaceIdentity
@@ -508,4 +508,4 @@ export {
   NamespaceSearchRouter,
   normalizeQmdResultPath
 };
-//# sourceMappingURL=chunk-RSMIRLKM.js.map
+//# sourceMappingURL=chunk-7UX44C4N.js.map

package/dist/{chunk-DJMVSUPK.js → chunk-A6G7K273.js}

@@ -1,9 +1,9 @@
 import {
   resolveDefaultNamespaceRoot
-} from "./chunk-6KHF6PAB.js";
+} from "./chunk-RH6QEGCT.js";
 import {
   StorageManager
-} from "./chunk-37HCPM56.js";
+} from "./chunk-WJLGUY27.js";
 import {
   composeLocationDayBody,
   composeLocationDayMeta,
@@ -23,7 +23,7 @@ import {
   serializeLocationDay,
   updateLocationSourceDay,
   writeLocationDay
-} from "./chunk-CLCMDKTB.js";
+} from "./chunk-3I3U6FFT.js";
 import {
   resolveNamespaceCapabilities
 } from "./chunk-2EMROIXS.js";
@@ -728,4 +728,4 @@ export {
   runLocationBackfill,
   runLocationCliCommand
 };
-//# sourceMappingURL=chunk-DJMVSUPK.js.map
+//# sourceMappingURL=chunk-A6G7K273.js.map

package/dist/{chunk-VC4J4UTI.js → chunk-AAM66QCP.js}

@@ -5,13 +5,13 @@ import {
   embeddingGenerationMembership,
   embeddingShardDirOf,
   isEmbeddingGenerationDirPath
-} from "./chunk-WWLAKRMX.js";
-import {
-  resolveSafeArchiveTarget
-} from "./chunk-GCGJW34D.js";
+} from "./chunk-3NFN4Y4P.js";
 import {
   EMBEDDING_SHARD_FILE_PATTERN
 } from "./chunk-TYT4TEQV.js";
+import {
+  resolveSafeArchiveTarget
+} from "./chunk-GCGJW34D.js";
 import {
   EmbeddingIndexStorageError
 } from "./chunk-Y57GJDG5.js";
@@ -369,4 +369,4 @@ export {
   applyChangesetEmbeddingGenerations,
   buildChangesetGenerationManifest
 };
-//# sourceMappingURL=chunk-VC4J4UTI.js.map
+//# sourceMappingURL=chunk-AAM66QCP.js.map

package/dist/{chunk-TZQOCQXB.js → chunk-AL6EHLB5.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-BTNNL7ZW.js";
 import {
   withHeldFileLock
-} from "./chunk-FFAZ2XFU.js";
+} from "./chunk-EHRE7ZG3.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -689,4 +689,4 @@ export {
   TierMigrationStatusStore,
   RecallHandleHistoryStore
 };
-//# sourceMappingURL=chunk-TZQOCQXB.js.map
+//# sourceMappingURL=chunk-AL6EHLB5.js.map

package/dist/{chunk-IJ4FEGZR.js → chunk-AMFCRZYB.js}

@@ -1,6 +1,6 @@
 import {
   isGenericRecallExcludedPath
-} from "./chunk-GE6HETIF.js";
+} from "./chunk-E5274WUC.js";
 import {
   normalizeProjectionPreview
 } from "./chunk-SCU65EZI.js";
@@ -209,4 +209,4 @@ export {
   browsePatternMatches,
   runMemoryBrowse
 };
-//# sourceMappingURL=chunk-IJ4FEGZR.js.map
+//# sourceMappingURL=chunk-AMFCRZYB.js.map

package/dist/{chunk-4K2H4KTR.js → chunk-AV46CT77.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   StorageManager
-} from "./chunk-37HCPM56.js";
+} from "./chunk-WJLGUY27.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-M5GVCJSJ.js";
 import {
   requestEntityCanonicalIdReconcile
-} from "./chunk-R7QY5ZVB.js";
+} from "./chunk-4NDWE44P.js";
 import {
   excludeSupportPassportPrivateMemories
 } from "./chunk-PWPIERBM.js";
@@ -765,4 +765,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-4K2H4KTR.js.map
+//# sourceMappingURL=chunk-AV46CT77.js.map

package/dist/{chunk-7PZHH4KC.js → chunk-AZEZSQ5R.js}

@@ -3,8 +3,12 @@ import {
   openProjectionReadonly,
   parseCurrentRow
 } from "./chunk-AL3UYZ5N.js";
+import {
+  isRecord
+} from "./chunk-A2IYSXDQ.js";
 
 // src/memory-projection-batch.ts
+import path from "path";
 function readProjectedMemoryStates(memoryDir, memoryIds) {
   const db = openProjectionReadonly(memoryDir);
   if (!db) return null;
@@ -56,8 +60,25 @@ function readProjectedMemoryStates(memoryDir, memoryIds) {
     db.close();
   }
 }
+function readProjectedMemoryPaths(memoryDir) {
+  const db = openProjectionReadonly(memoryDir);
+  if (!db) return null;
+  try {
+    const paths = /* @__PURE__ */ new Set();
+    for (const row of db.prepare("SELECT path_rel FROM memory_current").iterate()) {
+      const relative = isRecord(row) ? row.path_rel : void 0;
+      if (typeof relative === "string") paths.add(path.resolve(memoryDir, relative));
+    }
+    return paths;
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
 
 export {
-  readProjectedMemoryStates
+  readProjectedMemoryStates,
+  readProjectedMemoryPaths
 };
-//# sourceMappingURL=chunk-7PZHH4KC.js.map
+//# sourceMappingURL=chunk-AZEZSQ5R.js.map

package/dist/chunk-AZEZSQ5R.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-projection-batch.ts"],"sourcesContent":["import path from \"node:path\";\nimport type { MemoryProjectionCurrentState } from \"./types.js\";\nimport { isRecord } from \"./store-contract.js\";\nimport {\n  memoryCurrentSelectExpressions,\n  openProjectionReadonly,\n  parseCurrentRow,\n} from \"./memory-projection-store.js\";\n\nexport interface ProjectedMemoryStateBatch {\n  states: Map<string, MemoryProjectionCurrentState>;\n  /** Meta `rebuiltAt`; null when the projection never recorded one. */\n  rebuiltAt: string | null;\n  /**\n   * True only when the writer recorded that `memory_current` covers every active\n   * memory (an unscoped rebuild). Projections written before this flag existed,\n   * and scoped rebuilds, read as false.\n   */\n  complete: boolean;\n}\n\n/**\n * Read many current-state rows over ONE readonly connection, plus the meta the\n * recall path needs to decide whether the index can be trusted. Ids absent from\n * `memory_current` are simply missing from the map. Null means the projection\n * could not be opened or read.\n */\nexport function readProjectedMemoryStates(\n  memoryDir: string,\n  memoryIds: Iterable<string>,\n): ProjectedMemoryStateBatch | null {\n  const db = openProjectionReadonly(memoryDir);\n  if (!db) return null;\n  try {\n    const currentSelect = memoryCurrentSelectExpressions(db);\n    const select = db.prepare(\n      `\n        SELECT\n          memory_id,\n          category,\n          status,\n          lifecycle_state,\n          path_rel,\n          created_at,\n          updated_at,\n          archived_at,\n          superseded_at,\n          entity_ref,\n          source,\n          confidence,\n          confidence_tier,\n          memory_kind,\n          access_count,\n          last_accessed,\n          ${currentSelect.tagsJson},\n          ${currentSelect.previewText},\n          ${currentSelect.privateRecord}\n        FROM memory_current\n        WHERE memory_id = ?\n      `,\n    );\n    const states = new Map<string, MemoryProjectionCurrentState>();\n    for (const memoryId of memoryIds) {\n      const state = parseCurrentRow(memoryDir, select.get(memoryId) as Record<string, unknown> | undefined);\n      if (state) states.set(memoryId, state);\n    }\n    const meta = new Map<string, unknown>(\n      (db.prepare(\"SELECT key, value FROM meta WHERE key IN ('rebuiltAt', 'complete')\").all() as Array<{\n        key: string;\n        value: unknown;\n      }>).map((row) => [row.key, row.value]),\n    );\n    const rebuiltAt = meta.get(\"rebuiltAt\");\n    return {\n      states,\n      rebuiltAt: typeof rebuiltAt === \"string\" ? rebuiltAt : null,\n      complete: meta.get(\"complete\") === \"true\",\n    };\n  } catch {\n    return null;\n  } finally {\n    db.close();\n  }\n}\n\n/** Path-only census used to avoid parsing already-projected files during a fallback lookup. */\nexport function readProjectedMemoryPaths(memoryDir: string): Set<string> | null {\n  const db = openProjectionReadonly(memoryDir);\n  if (!db) return null;\n  try {\n    const paths = new Set<string>();\n    for (const row of db.prepare(\"SELECT path_rel FROM memory_current\").iterate()) {\n      const relative = isRecord(row) ? row.path_rel : undefined;\n      if (typeof relative === \"string\") paths.add(path.resolve(memoryDir, relative));\n    }\n    return paths;\n  } catch {\n    return null;\n  } finally {\n    db.close();\n  }\n}\n"],"mappings":";;;;;;;;;;AAAA,OAAO,UAAU;AA2BV,SAAS,0BACd,WACA,WACkC;AAClC,QAAM,KAAK,uBAAuB,SAAS;AAC3C,MAAI,CAAC,GAAI,QAAO;AAChB,MAAI;AACF,UAAM,gBAAgB,+BAA+B,EAAE;AACvD,UAAM,SAAS,GAAG;AAAA,MAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAkBM,cAAc,QAAQ;AAAA,YACtB,cAAc,WAAW;AAAA,YACzB,cAAc,aAAa;AAAA;AAAA;AAAA;AAAA,IAInC;AACA,UAAM,SAAS,oBAAI,IAA0C;AAC7D,eAAW,YAAY,WAAW;AAChC,YAAM,QAAQ,gBAAgB,WAAW,OAAO,IAAI,QAAQ,CAAwC;AACpG,UAAI,MAAO,QAAO,IAAI,UAAU,KAAK;AAAA,IACvC;AACA,UAAM,OAAO,IAAI;AAAA,MACd,GAAG,QAAQ,oEAAoE,EAAE,IAAI,EAGlF,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,KAAK,CAAC;AAAA,IACvC;AACA,UAAM,YAAY,KAAK,IAAI,WAAW;AACtC,WAAO;AAAA,MACL;AAAA,MACA,WAAW,OAAO,cAAc,WAAW,YAAY;AAAA,MACvD,UAAU,KAAK,IAAI,UAAU,MAAM;AAAA,IACrC;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,EACT,UAAE;AACA,OAAG,MAAM;AAAA,EACX;AACF;AAGO,SAAS,yBAAyB,WAAuC;AAC9E,QAAM,KAAK,uBAAuB,SAAS;AAC3C,MAAI,CAAC,GAAI,QAAO;AAChB,MAAI;AACF,UAAM,QAAQ,oBAAI,IAAY;AAC9B,eAAW,OAAO,GAAG,QAAQ,qCAAqC,EAAE,QAAQ,GAAG;AAC7E,YAAM,WAAW,SAAS,GAAG,IAAI,IAAI,WAAW;AAChD,UAAI,OAAO,aAAa,SAAU,OAAM,IAAI,KAAK,QAAQ,WAAW,QAAQ,CAAC;AAAA,IAC/E;AACA,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT,UAAE;AACA,OAAG,MAAM;AAAA,EACX;AACF;","names":[]}

package/dist/{chunk-VZBW6CDG.js → chunk-BOOFTFFE.js}

@@ -400,4 +400,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-VZBW6CDG.js.map
+//# sourceMappingURL=chunk-BOOFTFFE.js.map