@remnic/core 10.0.2 → 10.0.4

package/dist/{chunk-IB63OVUB.js → chunk-AJ6ORARY.js}

@@ -1,3 +1,8 @@
+import {
+  EMPTY_QMD_STATUS,
+  embedQmdFiles,
+  fetchQmdStatus
+} from "./chunk-IUM3VSHI.js";
 import {
   resolveEnsureCollectionArgs
 } from "./chunk-G26YNEOC.js";
@@ -20,11 +25,6 @@ import {
   qmdVersionToString,
   resolveQmdCapabilities
 } from "./chunk-SIGAGKNE.js";
-import {
-  EMPTY_QMD_STATUS,
-  embedQmdFiles,
-  fetchQmdStatus
-} from "./chunk-IUM3VSHI.js";
 import {
   clearQmdResultCaches,
   getCachedQmdSearch,
@@ -2028,4 +2028,4 @@ export {
   sharedDaemonSessionCountForTest,
   QmdClient
 };
-//# sourceMappingURL=chunk-IB63OVUB.js.map
+//# sourceMappingURL=chunk-AJ6ORARY.js.map

package/dist/{chunk-U6VC6RP3.js → chunk-AWLQNLTM.js}

@@ -1,6 +1,6 @@
 import {
   isPathInsideStorageRoot
-} from "./chunk-FF4KLI5W.js";
+} from "./chunk-LDPPTPO5.js";
 import {
   SecureStoreLockedError
 } from "./chunk-MAAL6OZV.js";
@@ -45,4 +45,4 @@ async function decodeCitationNamespace(getStorage, authorizedNamespaces, memoryP
 export {
   decodeCitationNamespace
 };
-//# sourceMappingURL=chunk-U6VC6RP3.js.map
+//# sourceMappingURL=chunk-AWLQNLTM.js.map

package/dist/{chunk-PJSK6OJM.js → chunk-BANSBRNX.js}

@@ -1,7 +1,7 @@
 import {
   encodeStoragePathSegment,
   resolveSafeStoragePath
-} from "./chunk-FF4KLI5W.js";
+} from "./chunk-LDPPTPO5.js";
 
 // src/write-quarantine.ts
 import { randomUUID } from "crypto";
@@ -198,4 +198,4 @@ export {
   DEFAULT_QUARANTINE_CAPS,
   WriteQuarantineStore
 };
-//# sourceMappingURL=chunk-PJSK6OJM.js.map
+//# sourceMappingURL=chunk-BANSBRNX.js.map

package/dist/{chunk-32HO62I4.js → chunk-BDHWKFGM.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-QPWUG2S3.js";
+} from "./chunk-NSQ3GUVO.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -620,4 +620,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-32HO62I4.js.map
+//# sourceMappingURL=chunk-BDHWKFGM.js.map

package/dist/{chunk-AW4QUFQF.js → chunk-BTNNL7ZW.js}

@@ -54,13 +54,14 @@ async function writeFileAtomically(outputPath, content, backupPath) {
     throw err;
   }
 }
-async function commitPreparedFileAtomically(tempPath, outputPath, backupPath) {
+async function commitPreparedFileAtomically(tempPath, outputPath, backupPath, beforeRename) {
   const dir = path.dirname(outputPath);
   let resolvedBackupPath;
   try {
     if (backupPath) {
       resolvedBackupPath = await copyExistingFileToBackup(outputPath, backupPath);
     }
+    if (beforeRename) await beforeRename();
     await rename(tempPath, outputPath);
     await syncDirectory(dir);
     return resolvedBackupPath;
@@ -75,4 +76,4 @@ export {
   writeFileAtomically,
   commitPreparedFileAtomically
 };
-//# sourceMappingURL=chunk-AW4QUFQF.js.map
+//# sourceMappingURL=chunk-BTNNL7ZW.js.map

package/dist/{chunk-AW4QUFQF.js.map → chunk-BTNNL7ZW.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/maintenance/atomic-file.ts"],"sourcesContent":["import path from \"node:path\";\nimport { copyFile, mkdir, open, rename, rm, stat } from \"node:fs/promises\";\n\nasync function syncDirectory(dir: string): Promise<void> {\n  let handle: Awaited<ReturnType<typeof open>> | undefined;\n  try {\n    handle = await open(dir, \"r\");\n    await handle.sync();\n  } catch {\n    // Directory fsync is best-effort across platforms and filesystems.\n  } finally {\n    await handle?.close().catch(() => undefined);\n  }\n}\n\nfunction tempPathFor(outputPath: string): string {\n  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;\n  return path.join(path.dirname(outputPath), `.${path.basename(outputPath)}.${suffix}.tmp`);\n}\n\nexport async function copyExistingFileToBackup(\n  sourcePath: string,\n  backupPath: string,\n): Promise<string | undefined> {\n  try {\n    await stat(sourcePath);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return undefined;\n    throw err;\n  }\n\n  await mkdir(path.dirname(backupPath), { recursive: true });\n  await copyFile(sourcePath, backupPath);\n  return backupPath;\n}\n\nexport async function writeFileAtomically(\n  outputPath: string,\n  content: string | Uint8Array,\n  backupPath?: string,\n): Promise<string | undefined> {\n  const dir = path.dirname(outputPath);\n  await mkdir(dir, { recursive: true });\n  const tempPath = tempPathFor(outputPath);\n  let handle: Awaited<ReturnType<typeof open>> | undefined;\n  let resolvedBackupPath: string | undefined;\n  try {\n    handle = await open(tempPath, \"w\");\n    if (typeof content === \"string\") {\n      await handle.writeFile(content, \"utf-8\");\n    } else {\n      await handle.writeFile(content);\n    }\n    await handle.sync();\n    await handle.close();\n    handle = undefined;\n\n    if (backupPath) {\n      resolvedBackupPath = await copyExistingFileToBackup(outputPath, backupPath);\n    }\n    await rename(tempPath, outputPath);\n    await syncDirectory(dir);\n    return resolvedBackupPath;\n  } catch (err) {\n    await handle?.close().catch(() => undefined);\n    await rm(tempPath, { force: true }).catch(() => undefined);\n    throw err;\n  }\n}\n\nexport async function commitPreparedFileAtomically(\n  tempPath: string,\n  outputPath: string,\n  backupPath?: string,\n): Promise<string | undefined> {\n  const dir = path.dirname(outputPath);\n  let resolvedBackupPath: string | undefined;\n  try {\n    if (backupPath) {\n      resolvedBackupPath = await copyExistingFileToBackup(outputPath, backupPath);\n    }\n    await rename(tempPath, outputPath);\n    await syncDirectory(dir);\n    return resolvedBackupPath;\n  } catch (err) {\n    await rm(tempPath, { force: true }).catch(() => undefined);\n    throw err;\n  }\n}\n"],"mappings":";AAAA,OAAO,UAAU;AACjB,SAAS,UAAU,OAAO,MAAM,QAAQ,IAAI,YAAY;AAExD,eAAe,cAAc,KAA4B;AACvD,MAAI;AACJ,MAAI;AACF,aAAS,MAAM,KAAK,KAAK,GAAG;AAC5B,UAAM,OAAO,KAAK;AAAA,EACpB,QAAQ;AAAA,EAER,UAAE;AACA,UAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,MAAS;AAAA,EAC7C;AACF;AAEA,SAAS,YAAY,YAA4B;AAC/C,QAAM,SAAS,GAAG,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,CAAC;AAClF,SAAO,KAAK,KAAK,KAAK,QAAQ,UAAU,GAAG,IAAI,KAAK,SAAS,UAAU,CAAC,IAAI,MAAM,MAAM;AAC1F;AAEA,eAAsB,yBACpB,YACA,YAC6B;AAC7B,MAAI;AACF,UAAM,KAAK,UAAU;AAAA,EACvB,SAAS,KAAK;AACZ,QAAK,IAA8B,SAAS,SAAU,QAAO;AAC7D,UAAM;AAAA,EACR;AAEA,QAAM,MAAM,KAAK,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACzD,QAAM,SAAS,YAAY,UAAU;AACrC,SAAO;AACT;AAEA,eAAsB,oBACpB,YACA,SACA,YAC6B;AAC7B,QAAM,MAAM,KAAK,QAAQ,UAAU;AACnC,QAAM,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACpC,QAAM,WAAW,YAAY,UAAU;AACvC,MAAI;AACJ,MAAI;AACJ,MAAI;AACF,aAAS,MAAM,KAAK,UAAU,GAAG;AACjC,QAAI,OAAO,YAAY,UAAU;AAC/B,YAAM,OAAO,UAAU,SAAS,OAAO;AAAA,IACzC,OAAO;AACL,YAAM,OAAO,UAAU,OAAO;AAAA,IAChC;AACA,UAAM,OAAO,KAAK;AAClB,UAAM,OAAO,MAAM;AACnB,aAAS;AAET,QAAI,YAAY;AACd,2BAAqB,MAAM,yBAAyB,YAAY,UAAU;AAAA,IAC5E;AACA,UAAM,OAAO,UAAU,UAAU;AACjC,UAAM,cAAc,GAAG;AACvB,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,UAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,MAAS;AAC3C,UAAM,GAAG,UAAU,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,MAAS;AACzD,UAAM;AAAA,EACR;AACF;AAEA,eAAsB,6BACpB,UACA,YACA,YAC6B;AAC7B,QAAM,MAAM,KAAK,QAAQ,UAAU;AACnC,MAAI;AACJ,MAAI;AACF,QAAI,YAAY;AACd,2BAAqB,MAAM,yBAAyB,YAAY,UAAU;AAAA,IAC5E;AACA,UAAM,OAAO,UAAU,UAAU;AACjC,UAAM,cAAc,GAAG;AACvB,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,UAAM,GAAG,UAAU,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,MAAS;AACzD,UAAM;AAAA,EACR;AACF;","names":[]}
+{"version":3,"sources":["../src/maintenance/atomic-file.ts"],"sourcesContent":["import path from \"node:path\";\nimport { copyFile, mkdir, open, rename, rm, stat } from \"node:fs/promises\";\n\nasync function syncDirectory(dir: string): Promise<void> {\n  let handle: Awaited<ReturnType<typeof open>> | undefined;\n  try {\n    handle = await open(dir, \"r\");\n    await handle.sync();\n  } catch {\n    // Directory fsync is best-effort across platforms and filesystems.\n  } finally {\n    await handle?.close().catch(() => undefined);\n  }\n}\n\nfunction tempPathFor(outputPath: string): string {\n  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;\n  return path.join(path.dirname(outputPath), `.${path.basename(outputPath)}.${suffix}.tmp`);\n}\n\nexport async function copyExistingFileToBackup(\n  sourcePath: string,\n  backupPath: string,\n): Promise<string | undefined> {\n  try {\n    await stat(sourcePath);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return undefined;\n    throw err;\n  }\n\n  await mkdir(path.dirname(backupPath), { recursive: true });\n  await copyFile(sourcePath, backupPath);\n  return backupPath;\n}\n\nexport async function writeFileAtomically(\n  outputPath: string,\n  content: string | Uint8Array,\n  backupPath?: string,\n): Promise<string | undefined> {\n  const dir = path.dirname(outputPath);\n  await mkdir(dir, { recursive: true });\n  const tempPath = tempPathFor(outputPath);\n  let handle: Awaited<ReturnType<typeof open>> | undefined;\n  let resolvedBackupPath: string | undefined;\n  try {\n    handle = await open(tempPath, \"w\");\n    if (typeof content === \"string\") {\n      await handle.writeFile(content, \"utf-8\");\n    } else {\n      await handle.writeFile(content);\n    }\n    await handle.sync();\n    await handle.close();\n    handle = undefined;\n\n    if (backupPath) {\n      resolvedBackupPath = await copyExistingFileToBackup(outputPath, backupPath);\n    }\n    await rename(tempPath, outputPath);\n    await syncDirectory(dir);\n    return resolvedBackupPath;\n  } catch (err) {\n    await handle?.close().catch(() => undefined);\n    await rm(tempPath, { force: true }).catch(() => undefined);\n    throw err;\n  }\n}\n\nexport async function commitPreparedFileAtomically(\n  tempPath: string,\n  outputPath: string,\n  backupPath?: string,\n  beforeRename?: () => void | Promise<void>,\n): Promise<string | undefined> {\n  const dir = path.dirname(outputPath);\n  let resolvedBackupPath: string | undefined;\n  try {\n    if (backupPath) {\n      resolvedBackupPath = await copyExistingFileToBackup(outputPath, backupPath);\n    }\n    if (beforeRename) await beforeRename();\n    await rename(tempPath, outputPath);\n    await syncDirectory(dir);\n    return resolvedBackupPath;\n  } catch (err) {\n    await rm(tempPath, { force: true }).catch(() => undefined);\n    throw err;\n  }\n}\n"],"mappings":";AAAA,OAAO,UAAU;AACjB,SAAS,UAAU,OAAO,MAAM,QAAQ,IAAI,YAAY;AAExD,eAAe,cAAc,KAA4B;AACvD,MAAI;AACJ,MAAI;AACF,aAAS,MAAM,KAAK,KAAK,GAAG;AAC5B,UAAM,OAAO,KAAK;AAAA,EACpB,QAAQ;AAAA,EAER,UAAE;AACA,UAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,MAAS;AAAA,EAC7C;AACF;AAEA,SAAS,YAAY,YAA4B;AAC/C,QAAM,SAAS,GAAG,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,CAAC;AAClF,SAAO,KAAK,KAAK,KAAK,QAAQ,UAAU,GAAG,IAAI,KAAK,SAAS,UAAU,CAAC,IAAI,MAAM,MAAM;AAC1F;AAEA,eAAsB,yBACpB,YACA,YAC6B;AAC7B,MAAI;AACF,UAAM,KAAK,UAAU;AAAA,EACvB,SAAS,KAAK;AACZ,QAAK,IAA8B,SAAS,SAAU,QAAO;AAC7D,UAAM;AAAA,EACR;AAEA,QAAM,MAAM,KAAK,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACzD,QAAM,SAAS,YAAY,UAAU;AACrC,SAAO;AACT;AAEA,eAAsB,oBACpB,YACA,SACA,YAC6B;AAC7B,QAAM,MAAM,KAAK,QAAQ,UAAU;AACnC,QAAM,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACpC,QAAM,WAAW,YAAY,UAAU;AACvC,MAAI;AACJ,MAAI;AACJ,MAAI;AACF,aAAS,MAAM,KAAK,UAAU,GAAG;AACjC,QAAI,OAAO,YAAY,UAAU;AAC/B,YAAM,OAAO,UAAU,SAAS,OAAO;AAAA,IACzC,OAAO;AACL,YAAM,OAAO,UAAU,OAAO;AAAA,IAChC;AACA,UAAM,OAAO,KAAK;AAClB,UAAM,OAAO,MAAM;AACnB,aAAS;AAET,QAAI,YAAY;AACd,2BAAqB,MAAM,yBAAyB,YAAY,UAAU;AAAA,IAC5E;AACA,UAAM,OAAO,UAAU,UAAU;AACjC,UAAM,cAAc,GAAG;AACvB,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,UAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,MAAS;AAC3C,UAAM,GAAG,UAAU,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,MAAS;AACzD,UAAM;AAAA,EACR;AACF;AAEA,eAAsB,6BACpB,UACA,YACA,YACA,cAC6B;AAC7B,QAAM,MAAM,KAAK,QAAQ,UAAU;AACnC,MAAI;AACJ,MAAI;AACF,QAAI,YAAY;AACd,2BAAqB,MAAM,yBAAyB,YAAY,UAAU;AAAA,IAC5E;AACA,QAAI,aAAc,OAAM,aAAa;AACrC,UAAM,OAAO,UAAU,UAAU;AACjC,UAAM,cAAc,GAAG;AACvB,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,UAAM,GAAG,UAAU,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,MAAS;AACzD,UAAM;AAAA,EACR;AACF;","names":[]}

package/dist/{chunk-MY7B3HYC.js → chunk-CLCMDKTB.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-C7HJ3NEI.js";
 import {
   writeFileAtomically
-} from "./chunk-AW4QUFQF.js";
+} from "./chunk-BTNNL7ZW.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -889,4 +889,4 @@ export {
   applyBriefingLocationContext,
   daySummaryAutoOptions
 };
-//# sourceMappingURL=chunk-MY7B3HYC.js.map
+//# sourceMappingURL=chunk-CLCMDKTB.js.map

package/dist/{chunk-AALVXJJ7.js → chunk-CQQTEDHS.js}

@@ -1,6 +1,6 @@
 import {
   rebuildMemoryProjection
-} from "./chunk-4A2UMSNB.js";
+} from "./chunk-DBA2W6VV.js";
 
 // src/convergence-refresh.ts
 async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, getStorage, searchEnabled) {
@@ -32,4 +32,4 @@ async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, get
 export {
   refreshConvergedNamespaces
 };
-//# sourceMappingURL=chunk-AALVXJJ7.js.map
+//# sourceMappingURL=chunk-CQQTEDHS.js.map

package/dist/{chunk-2SYRHFUG.js → chunk-CV5AMCPX.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-B7RWBZXW.js";
 import {
   StorageManager
-} from "./chunk-LHOIYLKH.js";
+} from "./chunk-ABET5LA5.js";
 import {
   getCachedEpisodeMap,
   setCachedEpisodeMap
@@ -109,4 +109,4 @@ export {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
 };
-//# sourceMappingURL=chunk-2SYRHFUG.js.map
+//# sourceMappingURL=chunk-CV5AMCPX.js.map

package/dist/{chunk-BTOHGPHC.js → chunk-CXG2T7BJ.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-32HO62I4.js";
+} from "./chunk-BDHWKFGM.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-RKDSELA3.js";
+} from "./chunk-Z63GU5NN.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-BTOHGPHC.js.map
+//# sourceMappingURL=chunk-CXG2T7BJ.js.map

package/dist/{chunk-4A2UMSNB.js → chunk-DBA2W6VV.js}

@@ -7,10 +7,10 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-A5N6ZEUW.js";
+} from "./chunk-H6FA36LC.js";
 import {
   StorageManager
-} from "./chunk-LHOIYLKH.js";
+} from "./chunk-ABET5LA5.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -21,10 +21,11 @@ import {
   readProjectedGovernanceRows,
   readProjectedNativeKnowledgeRows,
   writeProjectionMetaHighWater
-} from "./chunk-22DYJLFN.js";
+} from "./chunk-XVC7JU2N.js";
 import {
   MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
   buildLifecycleEventsForMemory,
+  compareMemoryLifecycleEvents,
   inferMemoryStatus,
   memoryLifecycleEventProjectionIdentity,
   sortMemoryLifecycleEvents,
@@ -44,10 +45,13 @@ import {
 } from "./chunk-RL6NEVXT.js";
 import {
   commitPreparedFileAtomically
-} from "./chunk-AW4QUFQF.js";
+} from "./chunk-BTNNL7ZW.js";
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-PWPIERBM.js";
+import {
+  throwIfAborted
+} from "./chunk-BTTPKDIL.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -56,8 +60,177 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/maintenance/rebuild-memory-projection.ts
-import path from "path";
+import path2 from "path";
 import { mkdir, rm, stat } from "fs/promises";
+
+// src/maintenance/projection-timeline.ts
+import path from "path";
+function loadTimelineEvents(memories, lifecycleEvents) {
+  if (lifecycleEvents.length > 0) {
+    return {
+      events: sortMemoryLifecycleEvents(lifecycleEvents),
+      usedLifecycleLedger: true
+    };
+  }
+  return {
+    events: sortMemoryLifecycleEvents(memories.flatMap((memory) => buildLifecycleEventsForMemory(memory))),
+    usedLifecycleLedger: false
+  };
+}
+function deduplicateTimelineEvents(events, sourcePathFor) {
+  const keptById = /* @__PURE__ */ new Map();
+  const unique = [];
+  const skipped = [];
+  const skippedBlankIds = [];
+  for (const event of sortMemoryLifecycleEvents(events)) {
+    const sourcePath = sourcePathFor(event);
+    if (!event.memoryId.trim()) {
+      skippedBlankIds.push({ eventId: event.eventId, path: sourcePath });
+      log.warn(
+        `projection rebuild skipped timeline event with blank memory id: event_id=${event.eventId} path=${sourcePath}`
+      );
+      continue;
+    }
+    const kept = keptById.get(event.eventId);
+    if (kept) {
+      skipped.push({
+        eventId: event.eventId,
+        keptPath: kept.path,
+        skippedPath: sourcePath
+      });
+      log.warn(
+        `projection rebuild skipped duplicate timeline event_id=${event.eventId}: kept=${kept.path} skipped=${sourcePath}`
+      );
+      continue;
+    }
+    keptById.set(event.eventId, { event, path: sourcePath });
+    unique.push(event);
+  }
+  return { events: unique, skipped, skippedBlankIds };
+}
+function internPool() {
+  const pool = /* @__PURE__ */ new Map();
+  return (value) => {
+    const existing = pool.get(value);
+    if (existing !== void 0) return existing;
+    pool.set(value, value);
+    return value;
+  };
+}
+function internLedgerEvent(event, intern) {
+  event.memoryId = intern(event.memoryId);
+  event.eventType = intern(event.eventType);
+  event.timestamp = intern(event.timestamp);
+  event.actor = intern(event.actor);
+  event.ruleVersion = intern(event.ruleVersion);
+  if (event.reasonCode) event.reasonCode = intern(event.reasonCode);
+  if (event.correlationId) event.correlationId = intern(event.correlationId);
+}
+async function consumeLifecycleLedger(events, ledgerPath, signal) {
+  const intern = internPool();
+  const best = /* @__PURE__ */ new Map();
+  const losers = [];
+  const blanks = [];
+  const identities = /* @__PURE__ */ new Set();
+  let sawEvent = false;
+  for await (const event of events) {
+    throwIfAborted(signal, "projection rebuild aborted");
+    sawEvent = true;
+    internLedgerEvent(event, intern);
+    identities.add(memoryLifecycleEventProjectionIdentity(event));
+    if (!event.memoryId.trim()) {
+      blanks.push(event);
+      continue;
+    }
+    const prev = best.get(event.eventId);
+    if (!prev) {
+      best.set(event.eventId, event);
+      continue;
+    }
+    if (compareMemoryLifecycleEvents(event, prev) < 0) {
+      losers.push(prev);
+      best.set(event.eventId, event);
+    } else {
+      losers.push(event);
+    }
+  }
+  if (!sawEvent) return null;
+  const sourceLifecycleLedgerEventCount = identities.size;
+  identities.clear();
+  const skippedBlankIds = sortMemoryLifecycleEvents(blanks).map((event) => {
+    log.warn(
+      `projection rebuild skipped timeline event with blank memory id: event_id=${event.eventId} path=${ledgerPath}`
+    );
+    return { eventId: event.eventId, path: ledgerPath };
+  });
+  const skipped = sortMemoryLifecycleEvents(losers).map((event) => {
+    log.warn(
+      `projection rebuild skipped duplicate timeline event_id=${event.eventId}: kept=${ledgerPath} skipped=${ledgerPath}`
+    );
+    return {
+      eventId: event.eventId,
+      keptPath: ledgerPath,
+      skippedPath: ledgerPath
+    };
+  });
+  return {
+    events: sortMemoryLifecycleEvents([...best.values()]),
+    usedLifecycleLedger: true,
+    sourceLifecycleLedgerEventCount,
+    skipped,
+    skippedBlankIds
+  };
+}
+async function loadProjectionTimeline(options) {
+  const ledgerPath = path.join(options.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+  const streamed = await consumeLifecycleLedger(
+    options.storage.iterateMemoryLifecycleEvents(),
+    ledgerPath,
+    options.signal
+  );
+  if (streamed) return streamed;
+  const timeline = loadTimelineEvents(options.memories, []);
+  const memoryPathById = new Map(
+    options.memories.map((memory) => [memory.frontmatter.id, memory.path])
+  );
+  const deduplicated = deduplicateTimelineEvents(
+    timeline.events,
+    (event) => memoryPathById.get(event.memoryId) ?? ledgerPath
+  );
+  return {
+    events: deduplicated.events,
+    usedLifecycleLedger: false,
+    sourceLifecycleLedgerEventCount: 0,
+    skipped: deduplicated.skipped,
+    skippedBlankIds: deduplicated.skippedBlankIds
+  };
+}
+
+// src/maintenance/projection-rebuild-abort.ts
+function projectionRebuildParentDisconnected() {
+  return new Error("projection rebuild runner parent disconnected");
+}
+function watchProjectionRebuildParent() {
+  const abort = new AbortController();
+  const stop = () => {
+    if (abort.signal.aborted) return;
+    abort.abort(projectionRebuildParentDisconnected());
+  };
+  process.on("disconnect", stop);
+  if (process.connected === false) stop();
+  return abort.signal;
+}
+async function throwIfProjectionRebuildAborted(signal) {
+  if (!signal) return;
+  await new Promise((resolve) => {
+    setImmediate(resolve);
+  });
+  if (!signal.aborted) return;
+  const reason = signal.reason;
+  throw reason instanceof Error ? reason : projectionRebuildParentDisconnected();
+}
+
+// src/maintenance/rebuild-memory-projection.ts
 async function backupExistingProjection(memoryDir, outputPath, now) {
   try {
     await stat(outputPath);
@@ -67,7 +240,7 @@ async function backupExistingProjection(memoryDir, outputPath, now) {
     }
     throw err;
   }
-  const backupPath = path.join(
+  const backupPath = path2.join(
     memoryDir,
     "archive",
     "memory-projection",
@@ -101,7 +274,8 @@ function toCurrentStateRow(memoryDir, memory) {
     accessCount: memory.frontmatter.accessCount,
     lastAccessed: memory.frontmatter.lastAccessed,
     tags: normalizeProjectionTags(memory.frontmatter.tags),
-    preview: normalizeProjectionPreview(memory.content),
+    // Copy the preview off the source string so the full document can be collected.
+    preview: Buffer.from(normalizeProjectionPreview(memory.content), "utf8").toString("utf8"),
     privateRecord: isSupportPassportPrivateMemory(memory)
   };
 }
@@ -176,18 +350,6 @@ async function loadLatestGovernanceProjection(memoryDir) {
     return null;
   }
 }
-function loadTimelineEvents(memories, lifecycleEvents) {
-  if (lifecycleEvents.length > 0) {
-    return {
-      events: sortMemoryLifecycleEvents(lifecycleEvents),
-      usedLifecycleLedger: true
-    };
-  }
-  return {
-    events: sortMemoryLifecycleEvents(memories.flatMap((memory) => buildLifecycleEventsForMemory(memory))),
-    usedLifecycleLedger: false
-  };
-}
 function normalizeScopedIso(value) {
   if (!value) return null;
   const trimmed = value.trim();
@@ -337,67 +499,39 @@ function selectProjectionMemories(tiers) {
   }
   return { allMemories, memories, skippedDuplicateMemories, skippedBlankIdMemories };
 }
-function deduplicateTimelineEvents(events, sourcePathFor) {
-  const keptById = /* @__PURE__ */ new Map();
-  const unique = [];
-  const skipped = [];
-  const skippedBlankIds = [];
-  for (const event of sortMemoryLifecycleEvents(events)) {
-    const sourcePath = sourcePathFor(event);
-    if (!event.memoryId.trim()) {
-      skippedBlankIds.push({ eventId: event.eventId, path: sourcePath });
-      log.warn(
-        `projection rebuild skipped timeline event with blank memory id: event_id=${event.eventId} path=${sourcePath}`
-      );
-      continue;
-    }
-    const kept = keptById.get(event.eventId);
-    if (kept) {
-      skipped.push({
-        eventId: event.eventId,
-        keptPath: kept.path,
-        skippedPath: sourcePath
-      });
-      log.warn(
-        `projection rebuild skipped duplicate timeline event_id=${event.eventId}: kept=${kept.path} skipped=${sourcePath}`
-      );
-      continue;
-    }
-    keptById.set(event.eventId, { event, path: sourcePath });
-    unique.push(event);
-  }
-  return { events: unique, skipped, skippedBlankIds };
-}
 async function loadAuthoritativeProjectionSnapshot(options) {
   const storage = assertInjectedStorageRooted("rebuildMemoryProjection", options.memoryDir, options.storage) ?? new StorageManager(options.memoryDir);
   storage.invalidateAllMemoriesCacheForDir({ indexedText: false });
-  const selected = selectProjectionMemories([
-    await storage.readAllMemories(),
-    await storage.readAllColdMemories(),
-    await storage.readArchivedMemories()
-  ]);
+  const corpusRead = {
+    retainRaw: options.retainRaw === true,
+    abortSignal: options.signal
+  };
+  const hot = await storage.readAllMemories(corpusRead);
+  await throwIfProjectionRebuildAborted(options.signal);
+  const cold = await storage.readAllColdMemories(corpusRead);
+  await throwIfProjectionRebuildAborted(options.signal);
+  const archived = await storage.readArchivedMemories(corpusRead);
+  await throwIfProjectionRebuildAborted(options.signal);
+  const selected = selectProjectionMemories([hot, cold, archived]);
   const allMemories = selected.allMemories;
   const projectionMemories = selected.memories;
-  const lifecycleEvents = await storage.readAllMemoryLifecycleEvents();
-  const timeline = loadTimelineEvents(projectionMemories, lifecycleEvents);
-  const lifecycleLedgerPath = path.join(
-    options.memoryDir,
-    "state",
-    "memory-lifecycle-ledger.jsonl"
-  );
-  const memoryPathById = new Map(
-    projectionMemories.map((memory) => [memory.frontmatter.id, memory.path])
-  );
-  const deduplicatedTimeline = deduplicateTimelineEvents(
-    timeline.events,
-    (event) => timeline.usedLifecycleLedger ? lifecycleLedgerPath : memoryPathById.get(event.memoryId) ?? lifecycleLedgerPath
-  );
-  const events = deduplicatedTimeline.events;
-  const usedLifecycleLedger = timeline.usedLifecycleLedger;
-  const sourceLifecycleLedgerEventCount = new Set(
-    lifecycleEvents.map(memoryLifecycleEventProjectionIdentity)
-  ).size;
   const currentRows = projectionMemories.map((memory) => toCurrentStateRow(options.memoryDir, memory));
+  if (options.retainRaw !== true) {
+    for (const memory of allMemories) memory.content = "";
+  }
+  const {
+    events,
+    usedLifecycleLedger,
+    sourceLifecycleLedgerEventCount,
+    skipped: skippedDuplicateTimelineEvents,
+    skippedBlankIds: skippedBlankIdTimelineEvents
+  } = await loadProjectionTimeline({
+    storage,
+    memoryDir: options.memoryDir,
+    memories: projectionMemories,
+    signal: options.signal
+  });
+  await throwIfProjectionRebuildAborted(options.signal);
   const scope = normalizeProjectionScope(options);
   const scopedMemories = filterMemoriesForProjectionScope(projectionMemories, scope);
   const scopedMemoryIds = new Set(scopedMemories.map((memory) => memory.frontmatter.id));
@@ -438,8 +572,8 @@ async function loadAuthoritativeProjectionSnapshot(options) {
     scope,
     skippedDuplicateMemories: selected.skippedDuplicateMemories,
     skippedBlankIdMemories: selected.skippedBlankIdMemories,
-    skippedDuplicateTimelineEvents: deduplicatedTimeline.skipped,
-    skippedBlankIdTimelineEvents: deduplicatedTimeline.skippedBlankIds
+    skippedDuplicateTimelineEvents,
+    skippedBlankIdTimelineEvents
   };
 }
 function readProjectedCurrentRows(memoryDir) {
@@ -513,7 +647,7 @@ function readProjectedTimelineRows(memoryDir) {
 }
 function writeProjectionDb(dbPath, nowIso, currentRows, timelineRows, entityMentionRows, nativeKnowledgeRows, governance, usedLifecycleLedger, sourceLifecycleLedgerEventCount, complete) {
   const db = openBetterSqlite3(dbPath);
-  const memoryDir = path.dirname(path.dirname(dbPath));
+  const memoryDir = path2.dirname(path2.dirname(dbPath));
   try {
     initializeMemoryProjectionDb(db);
     const insertMeta = db.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES (?, ?)");
@@ -774,6 +908,7 @@ async function rebuildMemoryProjection(options) {
   const now = options.now ?? /* @__PURE__ */ new Date();
   const outputPath = getMemoryProjectionPath(options.memoryDir);
   const snapshot = await loadAuthoritativeProjectionSnapshot(options);
+  await throwIfProjectionRebuildAborted(options.signal);
   let backupPath;
   if (!dryRun) {
     let nextCurrentRows = snapshot.currentRows;
@@ -824,7 +959,8 @@ async function rebuildMemoryProjection(options) {
       }
     }
     const tempPath = `${outputPath}.tmp`;
-    await mkdir(path.dirname(outputPath), { recursive: true });
+    await mkdir(path2.dirname(outputPath), { recursive: true });
+    await throwIfProjectionRebuildAborted(options.signal);
     await rm(tempPath, { force: true });
     writeProjectionDb(
       tempPath,
@@ -838,8 +974,20 @@ async function rebuildMemoryProjection(options) {
       snapshot.sourceLifecycleLedgerEventCount,
       !hasScopedProjectionFilter(snapshot.scope)
     );
-    backupPath = await backupExistingProjection(options.memoryDir, outputPath, now);
-    backupPath = await commitPreparedFileAtomically(tempPath, outputPath, backupPath);
+    try {
+      await throwIfProjectionRebuildAborted(options.signal);
+      backupPath = await backupExistingProjection(options.memoryDir, outputPath, now);
+      await throwIfProjectionRebuildAborted(options.signal);
+      backupPath = await commitPreparedFileAtomically(
+        tempPath,
+        outputPath,
+        backupPath,
+        () => throwIfProjectionRebuildAborted(options.signal)
+      );
+    } catch (err) {
+      if (options.signal?.aborted) await rm(tempPath, { force: true });
+      throw err;
+    }
   }
   return {
     dryRun,
@@ -1002,9 +1150,10 @@ async function repairMemoryProjection(options) {
 }
 
 export {
+  watchProjectionRebuildParent,
   backupExistingProjection,
   rebuildMemoryProjection,
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-4A2UMSNB.js.map
+//# sourceMappingURL=chunk-DBA2W6VV.js.map