@remnic/core 9.17.1 → 9.19.0

package/dist/{chunk-7YJLCNPF.js → chunk-HRREDJSL.js}

@@ -23,11 +23,11 @@ import {
 import {
   assertMemoryFrontmatterId,
   warnProjectionFallback
-} from "./chunk-V57NLO5P.js";
+} from "./chunk-HKF5VASQ.js";
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-N7DK67GZ.js";
+} from "./chunk-WYL5ODHJ.js";
 import {
   appendLifecycleEventsSerialized,
   drainPendingLifecycleLedgerForSync,
@@ -60,12 +60,13 @@ import {
 } from "./chunk-SCU65EZI.js";
 import {
   markProjectedMemoryPathInvalid,
+  openProjectionReadonly,
   readProjectedGovernanceRecord,
   readProjectedMemoryBrowse,
   readProjectedMemoryState,
   readProjectedMemoryTimeline,
   updateProjectedMemoryPath
-} from "./chunk-347WD2LE.js";
+} from "./chunk-3CSX3ETE.js";
 import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
@@ -141,7 +142,7 @@ import {
 } from "./chunk-P7FMDTKL.js";
 import {
   resolveNamespaceCapabilities
-} from "./chunk-SCCO46KZ.js";
+} from "./chunk-RDQGLJRR.js";
 import {
   isPathInsideStorageRoot
 } from "./chunk-FF4KLI5W.js";
@@ -167,6 +168,29 @@ import {
   log
 } from "./chunk-3WCASNQZ.js";
 
+// src/maintenance/projection-support.ts
+import path from "path";
+function readProjectionRebuiltAt(memoryDir) {
+  const db = openProjectionReadonly(memoryDir);
+  if (!db) return null;
+  try {
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'rebuiltAt'").get();
+    return typeof row?.value === "string" && row.value.length > 0 ? row.value : null;
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function assertInjectedStorageRooted(label, memoryDir, injected) {
+  if (injected && path.resolve(injected.dir) !== path.resolve(memoryDir)) {
+    throw new Error(
+      `${label}: storage.dir (${injected.dir}) must match memoryDir (${memoryDir})`
+    );
+  }
+  return injected;
+}
+
 // src/storage.ts
 import {
   lstat as lstat2,
@@ -182,11 +206,11 @@ import {
 } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, readFileSync, statSync } from "fs";
 import { createHash as createHash4 } from "crypto";
-import path7 from "path";
+import path8 from "path";
 
 // src/storage/memory-read-store.ts
 import { lstat, readdir, realpath, stat } from "fs/promises";
-import path from "path";
+import path2 from "path";
 var MemoryReadStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -214,7 +238,7 @@ var MemoryReadStore = class {
       if (!/^[a-z][a-z0-9-]{0,63}$/.test(source)) continue;
       let entries;
       try {
-        entries = await readdir(path.join(this.deps.wearablesDir, source));
+        entries = await readdir(path2.join(this.deps.wearablesDir, source));
       } catch (err) {
         if (err.code === "ENOENT") continue;
         throw err;
@@ -245,7 +269,7 @@ var MemoryReadStore = class {
         try {
           const entries = await readdir(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
+            const fullPath = path2.join(dir, entry.name);
             if (entry.isDirectory()) {
               await readDir(fullPath);
               continue;
@@ -297,7 +321,7 @@ var MemoryReadStore = class {
       const subdirs = [];
       for (const entry of entries) {
         if (entry.isSymbolicLink()) continue;
-        const fullPath = path.join(dir, entry.name);
+        const fullPath = path2.join(dir, entry.name);
         if (entry.isDirectory()) {
           subdirs.push(fullPath);
         } else if (entry.name.endsWith(".md")) {
@@ -313,7 +337,7 @@ var MemoryReadStore = class {
       }
     };
     for (const dir of RECALL_FALLBACK_DIRS) {
-      await collectPaths(path.join(this.deps.baseDir, dir));
+      await collectPaths(path2.join(this.deps.baseDir, dir));
     }
     return filePaths;
   }
@@ -393,7 +417,7 @@ var MemoryReadStore = class {
         const entries = await readdir(dir, { withFileTypes: true });
         const subdirs = [];
         for (const entry of entries) {
-          const fullPath = path.join(dir, entry.name);
+          const fullPath = path2.join(dir, entry.name);
           if (entry.isDirectory()) {
             subdirs.push(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -427,11 +451,11 @@ var MemoryReadStore = class {
           content: parsed.content
         };
       }
-      const normalizedPath = filePath.split(path.sep).join("/");
+      const normalizedPath = filePath.split(path2.sep).join("/");
       if (normalizedPath.includes("/entities/") && filePath.endsWith(".md")) {
         const entity = parseEntityFile(raw, this.deps.entitySchemas);
         if (!entity.name) return null;
-        const nameWithoutExt = path.basename(filePath, ".md");
+        const nameWithoutExt = path2.basename(filePath, ".md");
         const fileMtime = entity.updated || await stat(filePath).then((s) => s.mtime.toISOString()).catch(() => (/* @__PURE__ */ new Date(0)).toISOString());
         return {
           path: filePath,
@@ -615,7 +639,7 @@ var MemoryReadStore = class {
       const questions = [];
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path.join(this.deps.questionsDir, file);
+        const filePath = path2.join(this.deps.questionsDir, file);
         const raw = await readMaybeEncryptedFile(filePath, this.deps._secureStoreKey, this.deps.baseDir);
         const parsed = this.deps.parseQuestionFile(raw, filePath);
         if (parsed) {
@@ -652,7 +676,7 @@ function selfDeps(self) {
 
 // src/storage/entity-store.ts
 import { readdir as readdir2, unlink } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 var EntityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -680,7 +704,7 @@ var EntityStore = class {
       log.debug(`fuzzy match: "${normalized}" \u2192 existing "${match}"`);
       normalized = match;
     }
-    const filePath = path2.join(this.deps.entitiesDir, `${normalized}.md`);
+    const filePath = path3.join(this.deps.entitiesDir, `${normalized}.md`);
     let entity = {
       name,
       type,
@@ -791,7 +815,7 @@ var EntityStore = class {
    * Set or rewrite the synthesis layer of an entity file.
    */
   async updateEntitySynthesis(name, synthesis, options = {}) {
-    const filePath = path2.join(this.deps.entitiesDir, `${name}.md`);
+    const filePath = path3.join(this.deps.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.deps.readStorageSecureFile(filePath);
@@ -843,7 +867,7 @@ var EntityStore = class {
         const results = await Promise.all(
           batch.map(async (entry) => {
             try {
-              return await this.deps.readStorageSecureFile(path2.join(this.deps.entitiesDir, entry));
+              return await this.deps.readStorageSecureFile(path3.join(this.deps.entitiesDir, entry));
             } catch (err) {
               if (err instanceof SecureStoreLockedError) throw err;
               if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -956,7 +980,7 @@ ${rows.join("\n")}
           extraSections: []
         };
         for (const file of files) {
-          const filePath = path2.join(this.deps.entitiesDir, file);
+          const filePath = path3.join(this.deps.entitiesDir, file);
           try {
             const content = await this.deps.readStorageSecureFile(filePath);
             const parsed = parseEntityFile(content, this.deps.entitySchemas);
@@ -1087,10 +1111,10 @@ ${rows.join("\n")}
         }
         mergedEntity.created = mergedEntity.created || mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
         mergedEntity.updated = mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
-        const canonicalPath = path2.join(this.deps.entitiesDir, `${canonical}.md`);
+        const canonicalPath = path3.join(this.deps.entitiesDir, `${canonical}.md`);
         await this.deps.writeStorageSecureFile(canonicalPath, serializeEntityFile(mergedEntity, this.deps.entitySchemas));
         for (const file of files) {
-          const filePath = path2.join(this.deps.entitiesDir, file);
+          const filePath = path3.join(this.deps.entitiesDir, file);
           if (filePath !== canonicalPath) {
             try {
               await unlink(filePath);
@@ -1110,7 +1134,7 @@ ${rows.join("\n")}
 
 // src/storage/identity-continuity-store.ts
 import { readdir as readdir3 } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 var IdentityContinuityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -1135,7 +1159,7 @@ var IdentityContinuityStore = class {
     const date = nowIso.slice(0, 10);
     const id = this.deps.generateId("incident");
     const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path3.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
+    const filePath = path4.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
     await this.deps.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
     return { ...incident, filePath };
   }
@@ -1148,7 +1172,7 @@ var IdentityContinuityStore = class {
       const incidents = [];
       for (const file of candidates) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path3.join(this.deps.identityIncidentsDir, file);
+        const filePath = path4.join(this.deps.identityIncidentsDir, file);
         try {
           const raw = await this.deps.readStorageSecureFile(filePath);
           const parsed = parseContinuityIncident(raw);
@@ -1179,7 +1203,7 @@ var IdentityContinuityStore = class {
     await this.deps.ensureDirectories();
     const safeKey = this.sanitizeIdentityAuditKey(key);
     const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-    const filePath = path3.join(dir, `${safeKey}.md`);
+    const filePath = path4.join(dir, `${safeKey}.md`);
     await this.deps.writeStorageSecureFile(filePath, content);
     return filePath;
   }
@@ -1187,7 +1211,7 @@ var IdentityContinuityStore = class {
     try {
       const safeKey = this.sanitizeIdentityAuditKey(key);
       const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-      return await this.deps.readStorageSecureFile(path3.join(dir, `${safeKey}.md`));
+      return await this.deps.readStorageSecureFile(path4.join(dir, `${safeKey}.md`));
     } catch (err) {
       if (err instanceof Error && err.message === "Invalid identity audit key") return null;
       if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -1243,12 +1267,12 @@ var IdentityContinuityStore = class {
     const fileNames = await this.readContinuityIncidentFileNames();
     const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
     if (directMatch) {
-      const directPath = path3.join(this.deps.identityIncidentsDir, directMatch);
+      const directPath = path4.join(this.deps.identityIncidentsDir, directMatch);
       const parsed = await this.readContinuityIncidentFile(directPath);
       if (parsed?.id === id) return directPath;
     }
     for (const fileName of fileNames) {
-      const filePath = path3.join(this.deps.identityIncidentsDir, fileName);
+      const filePath = path4.join(this.deps.identityIncidentsDir, fileName);
       const parsed = await this.readContinuityIncidentFile(filePath);
       if (parsed?.id === id) return filePath;
     }
@@ -1278,9 +1302,9 @@ function decodeYamlScalar(value) {
 }
 
 // src/orchestration/qmd-result-resolver.ts
-import path4 from "path";
+import path5 from "path";
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path4.isAbsolute(resultPath)) return null;
+  if (!resultPath || path5.isAbsolute(resultPath)) return null;
   const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
@@ -1293,9 +1317,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path4.resolve(storageDir);
+  const storageRoot = path5.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path4.resolve(candidate);
+    const resolved = path5.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -1303,18 +1327,18 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path4.join(storageRoot, normalized));
+    addCandidate(path5.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path4.join(storageRoot, "facts", normalized));
+      addCandidate(path5.join(storageRoot, "facts", normalized));
     }
   };
-  if (path4.isAbsolute(resultPath)) {
+  if (path5.isAbsolute(resultPath)) {
     addCandidate(resultPath);
-    const relative = path4.relative(storageRoot, path4.resolve(resultPath));
-    if (relative && !relative.startsWith("..") && !path4.isAbsolute(relative)) {
-      const normalized = relative.split(path4.sep).join("/");
+    const relative = path5.relative(storageRoot, path5.resolve(resultPath));
+    if (relative && !relative.startsWith("..") && !path5.isAbsolute(relative)) {
+      const normalized = relative.split(path5.sep).join("/");
       if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-        addCandidate(path4.join(storageRoot, "facts", normalized));
+        addCandidate(path5.join(storageRoot, "facts", normalized));
       }
     }
   } else {
@@ -1349,7 +1373,7 @@ var QmdResultResolver = class {
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir ? path4.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path5.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -1379,7 +1403,7 @@ var QmdResultResolver = class {
           continue;
         }
         try {
-          const coldRoot = path4.join(storageDir, "cold");
+          const coldRoot = path5.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(
             coldRoot,
             parts.relativePath
@@ -1438,9 +1462,9 @@ var QmdResultResolver = class {
           error: err.message
         });
       }
-      if (!path4.isAbsolute(resultPath)) return null;
+      if (!path5.isAbsolute(resultPath)) return null;
     }
-    if (path4.isAbsolute(resultPath)) {
+    if (path5.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -1480,7 +1504,7 @@ var QmdResultResolver = class {
     );
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path4.isAbsolute(memory.path)) {
+    if (path5.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(
         memory.path,
         fallbackStorage,
@@ -1504,17 +1528,17 @@ var QmdResultResolver = class {
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path4.resolve(resultPath);
+    const resolvedPath = path5.resolve(resultPath);
     const config = this.getConfig();
-    const memoryRoot = path4.resolve(config.memoryDir);
-    const namespacesRoot = path4.join(memoryRoot, "namespaces");
+    const memoryRoot = path5.resolve(config.memoryDir);
+    const namespacesRoot = path5.join(memoryRoot, "namespaces");
     const fallbackStorageDir = storageDirOrNull(fallbackStorage);
     const matches = [];
     const seenDirs = /* @__PURE__ */ new Set();
     const maybeAddStorage = (storage, namespace) => {
       const storageDir = storageDirOrNull(storage);
       if (!storageDir) return;
-      const candidateRoot = path4.resolve(storageDir);
+      const candidateRoot = path5.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -1532,7 +1556,7 @@ var QmdResultResolver = class {
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path4.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path5.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(
@@ -2181,7 +2205,7 @@ function fuseDay(date, inputs, options = {}) {
 
 // src/wearables/fusion/store.ts
 import { createHash as createHash2 } from "crypto";
-import * as path5 from "path";
+import * as path6 from "path";
 var FUSION_KIND = "wearable-fusion";
 function hashFusionBody(conversations) {
   return createHash2("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
@@ -2368,7 +2392,7 @@ var FusionArtifactStore = class {
         `invalid wearable fusion date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path5.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
+    return path6.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
   }
   async writeFusedDay(date, serialized) {
     const filePath = this.fusedDayPath(date);
@@ -2405,7 +2429,7 @@ var FusionArtifactStore = class {
   }
   /** List dates with stored fused artifacts, newest first. */
   async listFusedDays() {
-    const fusionDir = path5.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path6.join(this.wearablesDir, FUSION_DIR_NAME);
     await this.assertPathContained(fusionDir);
     let entries;
     try {
@@ -2449,10 +2473,10 @@ var FusionArtifactStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path5.resolve(this.memoryDir);
+      rootReal = path6.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.wearablesDir);
-    await this.assertNoEscape(rootReal, path5.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path6.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertFusionDirNotSymlinked();
   }
@@ -2466,7 +2490,7 @@ var FusionArtifactStore = class {
    * (a fresh write creates a real directory lexically under the root).
    */
   async assertFusionDirNotSymlinked() {
-    const fusionDir = path5.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path6.join(this.wearablesDir, FUSION_DIR_NAME);
     let stat4;
     try {
       stat4 = await this.io.lstat(fusionDir);
@@ -2996,7 +3020,7 @@ function isEntitySynthesisStale(entity) {
 
 // src/storage/content-hash-index.ts
 import { mkdir, stat as stat2 } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 var CONTENT_HASH_INDEX_LOCK_STALE_MS = 3e4;
 var CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS = 5;
 var CONTENT_HASH_INDEX_RETRY_BASE_MS = 500;
@@ -3056,8 +3080,8 @@ var ContentHashIndex = class _ContentHashIndex {
    * re-read on the hot path.
    */
   lastSyncedFingerprint = null;
-  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path6.dirname(stateDir), lockOptions = {}) {
-    this.filePath = path6.join(stateDir, "fact-hashes.txt");
+  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path7.dirname(stateDir), lockOptions = {}) {
+    this.filePath = path7.join(stateDir, "fact-hashes.txt");
     this.secureStoreKeyProvider = secureStoreKeyProvider;
     this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;
     this.memoryDir = memoryDir;
@@ -3149,7 +3173,7 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Persist index to disk if changed (plain whole-file overwrite). */
   async save() {
     if (!this.dirty) return;
-    await mkdir(path6.dirname(this.filePath), { recursive: true });
+    await mkdir(path7.dirname(this.filePath), { recursive: true });
     const publishedAdded = new Set(this.added);
     const publishedRemoved = new Set(this.removed);
     const serialized = [...this.hashes].join("\n") + "\n";
@@ -3196,7 +3220,7 @@ var ContentHashIndex = class _ContentHashIndex {
    */
   async saveMergingWithDisk() {
     if (!this.dirty) return;
-    await mkdir(path6.dirname(this.filePath), { recursive: true });
+    await mkdir(path7.dirname(this.filePath), { recursive: true });
     const publish = async () => {
       const publishedAdded = new Set(this.added);
       const publishedRemoved = new Set(this.removed);
@@ -3215,7 +3239,7 @@ var ContentHashIndex = class _ContentHashIndex {
         if (err instanceof SecureStoreLockedError) throw err;
         if (!isErrnoCode(err, "ENOENT")) throw err;
       }
-      await mkdir(path6.dirname(this.filePath), { recursive: true });
+      await mkdir(path7.dirname(this.filePath), { recursive: true });
       await writeMaybeEncryptedFile(
         this.filePath,
         [...merged].join("\n") + "\n",
@@ -3282,7 +3306,7 @@ var ContentHashIndex = class _ContentHashIndex {
    * fired retry) simply yields `acquired=false` after the bounded wait.
    */
   async rebuildUnderLock(populate) {
-    await mkdir(path6.dirname(this.filePath), { recursive: true });
+    await mkdir(path7.dirname(this.filePath), { recursive: true });
     let published = false;
     await withHeldFileLock(
       `${this.filePath}.lock`,
@@ -4083,17 +4107,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path7.basename(pathRel, ".md").toLowerCase();
+  const basename = path8.basename(pathRel, ".md").toLowerCase();
   const separator = basename.indexOf("-");
   if (separator <= 0) return void 0;
   const candidate = basename.slice(0, separator);
   return KNOWN_ENTITY_FILENAME_PREFIXES.has(candidate) ? candidate : void 0;
 }
 function normalizeFrontmatterForPath(frontmatter, pathRel, content = "") {
-  const normalizedPath = pathRel.split(path7.sep).join("/");
+  const normalizedPath = pathRel.split(path8.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path7.basename(pathRel, ".md");
+    const basename = path8.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -4759,8 +4783,8 @@ var StorageManager3 = class _StorageManager {
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path7.relative(this.stateDir, path7.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path7.isAbsolute(rel);
+    const rel = path8.relative(this.stateDir, path8.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path8.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -4860,8 +4884,8 @@ var StorageManager3 = class _StorageManager {
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path7.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path7.sep}`) || rel.startsWith(`archive${path7.sep}`);
+    const rel = path8.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path8.sep}`) || rel.startsWith(`archive${path8.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -4948,7 +4972,7 @@ var StorageManager3 = class _StorageManager {
         void 0,
         this.baseDir
       );
-      const rel = path7.relative(this.baseDir, filePath).split(path7.sep).join("/");
+      const rel = path8.relative(this.baseDir, filePath).split(path8.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -5028,13 +5052,13 @@ var StorageManager3 = class _StorageManager {
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path7.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path8.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path7.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path8.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
     const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : kind === "cold-write" ? ".cold-write-version.log" : ".memory-corpus-version.log";
-    return path7.join(this.stateDir, fileName);
+    return path8.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -5126,7 +5150,7 @@ var StorageManager3 = class _StorageManager {
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path7.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path8.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -5142,7 +5166,7 @@ var StorageManager3 = class _StorageManager {
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    return path7.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path8.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -5240,25 +5264,25 @@ var StorageManager3 = class _StorageManager {
     });
   }
   get factsDir() {
-    return path7.join(this.baseDir, "facts");
+    return path8.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path7.join(this.baseDir, "corrections");
+    return path8.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path7.join(this.baseDir, "procedures");
+    return path8.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path7.join(this.baseDir, "reasoning-traces");
+    return path8.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path7.join(this.baseDir, "entities");
+    return path8.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path7.resolve(this.entitiesDir, `${name}.md`);
-    const relative = path7.relative(this.entitiesDir, filePath);
-    if (relative === "" || relative.startsWith("..") || path7.isAbsolute(relative)) {
+    const filePath = path8.resolve(this.entitiesDir, `${name}.md`);
+    const relative = path8.relative(this.entitiesDir, filePath);
+    if (relative === "" || relative.startsWith("..") || path8.isAbsolute(relative)) {
       return null;
     }
     return filePath;
@@ -5279,10 +5303,10 @@ var StorageManager3 = class _StorageManager {
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path7.resolve(filePath);
-    const base = path7.resolve(this.baseDir);
-    const rel = path7.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path7.sep}`) || path7.isAbsolute(rel)) {
+    const resolved = path8.resolve(filePath);
+    const base = path8.resolve(this.baseDir);
+    const rel = path8.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path8.sep}`) || path8.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -5294,7 +5318,7 @@ var StorageManager3 = class _StorageManager {
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path7.relative(this.baseDir, target).split(path7.sep).join("/");
+    const relPath = path8.relative(this.baseDir, target).split(path8.sep).join("/");
     const cache = await this.loadOfflineSyncDigestCache();
     const cached = cache.get(relPath);
     if (cached && cached.statBytes === st.size && cached.mtimeMs === st.mtimeMs && cached.ctimeMs === st.ctimeMs && !cached.encrypted) {
@@ -5355,7 +5379,7 @@ var StorageManager3 = class _StorageManager {
         const bytes = typeof record.bytes === "number" ? record.bytes : NaN;
         const sha256 = typeof record.sha256 === "string" ? record.sha256 : "";
         const encrypted = record.encrypted === true;
-        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path7.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
+        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path8.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
           continue;
         }
         cache.set(cachePath, { statBytes, mtimeMs, ctimeMs, encrypted, sha256, bytes });
@@ -5397,7 +5421,7 @@ var StorageManager3 = class _StorageManager {
       const cache = this.offlineSyncDigestCache;
       if (!cache) return;
       const entries = [...cache.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([entryPath, entry]) => ({ path: entryPath, ...entry }));
-      await mkdir2(path7.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir2(path8.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -5442,10 +5466,10 @@ var StorageManager3 = class _StorageManager {
     this.invalidateAllMemoriesCache();
     this.invalidateKnowledgeIndexCache();
     this.factHashIndexAuthoritative = false;
-    if (filePath.includes(`${path7.sep}cold${path7.sep}`)) {
+    if (filePath.includes(`${path8.sep}cold${path8.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
-    if (filePath.includes(`${path7.sep}artifacts${path7.sep}`)) {
+    if (filePath.includes(`${path8.sep}artifacts${path8.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
     this.bumpMemoryStatusVersion();
@@ -5516,7 +5540,7 @@ var StorageManager3 = class _StorageManager {
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir2(path7.dirname(filePath), { recursive: true });
+    await mkdir2(path8.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -5542,13 +5566,13 @@ var StorageManager3 = class _StorageManager {
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path7.join(this.baseDir, "state");
+    return path8.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path7.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path8.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path7.join(this.stateDir, "entity-synthesis-queue.json");
+    return path8.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -5558,7 +5582,7 @@ var StorageManager3 = class _StorageManager {
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path7.join(this.stateDir, "tombstones.jsonl");
+    return path8.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -5831,55 +5855,55 @@ var StorageManager3 = class _StorageManager {
     return null;
   }
   get questionsDir() {
-    return path7.join(this.baseDir, "questions");
+    return path8.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path7.join(this.baseDir, "artifacts");
+    return path8.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path7.join(this.baseDir, "identity");
+    return path8.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path7.join(this.identityDir, "identity-anchor.md");
+    return path8.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path7.join(this.identityDir, "incidents");
+    return path8.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path7.join(this.identityDir, "audits", "weekly");
+    return path8.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path7.join(this.identityDir, "audits", "monthly");
+    return path8.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path7.join(this.identityDir, "improvement-loops.md");
+    return path8.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path7.join(this.identityDir, "reflections.md");
+    return path8.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path7.join(this.baseDir, "profile.md");
+    return path8.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path7.join(this.stateDir, "memory-actions.jsonl");
+    return path8.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path7.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path8.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path7.join(this.stateDir, "compression-guidelines.md");
+    return path8.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path7.join(this.stateDir, "compression-guidelines.draft.md");
+    return path8.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path7.join(this.stateDir, "compression-guideline-state.json");
+    return path8.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path7.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path8.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path7.join(this.stateDir, "behavior-signals.jsonl");
+    return path8.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -5911,7 +5935,7 @@ var StorageManager3 = class _StorageManager {
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path7.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path8.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -5942,7 +5966,7 @@ var StorageManager3 = class _StorageManager {
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path7.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path8.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     try {
       const raw = readFileSync(aliasPath, "utf-8");
@@ -5965,9 +5989,9 @@ var StorageManager3 = class _StorageManager {
   }
   async ensureDirectories() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir2(path7.join(this.factsDir, today), { recursive: true });
-    await mkdir2(path7.join(this.proceduresDir, today), { recursive: true });
-    await mkdir2(path7.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir2(path8.join(this.factsDir, today), { recursive: true });
+    await mkdir2(path8.join(this.proceduresDir, today), { recursive: true });
+    await mkdir2(path8.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir2(this.correctionsDir, { recursive: true });
     await mkdir2(this.entitiesDir, { recursive: true });
     await mkdir2(this.stateDir, { recursive: true });
@@ -5977,7 +6001,7 @@ var StorageManager3 = class _StorageManager {
     await mkdir2(this.identityIncidentsDir, { recursive: true });
     await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir2(path7.join(this.baseDir, "config"), { recursive: true });
+    await mkdir2(path8.join(this.baseDir, "config"), { recursive: true });
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
     }
@@ -5997,11 +6021,11 @@ var StorageManager3 = class _StorageManager {
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir2(this.correctionsDir, { recursive: true });
-      return path7.join(this.correctionsDir, `${id}.md`);
+      return path8.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path7.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path8.join(getCategoryDir(this.baseDir, category), today);
     await mkdir2(datedDir, { recursive: true });
-    return path7.join(datedDir, `${id}.md`);
+    return path8.join(datedDir, `${id}.md`);
   }
   async writeMemory(category, content, options = {}) {
     await this.ensureDirectories();
@@ -6306,7 +6330,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path7.join(this.artifactsDir, day);
+    const dir = path8.join(this.artifactsDir, day);
     await mkdir2(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -6331,7 +6355,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path7.join(dir, `${id}.md`);
+    const filePath = path8.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
@@ -6607,7 +6631,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path7.join(this.baseDir, "cold");
+    const coldRoot = path8.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -6699,7 +6723,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path7.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path8.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -6762,7 +6786,7 @@ ${sanitized.text}
       try {
         const entries = await readdir4(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path7.join(dir, entry.name);
+          const fullPath = path8.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -6795,7 +6819,7 @@ ${sanitized.text}
     return this.memoryReadStore.readMemoryByPath(filePath);
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path7.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path8.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -6810,13 +6834,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path7.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path8.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path7.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path8.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path7.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path8.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     const fileContent = `${serializeFrontmatter(memory.frontmatter)}
@@ -6829,8 +6853,8 @@ ${memory.content}
   }
   async moveMemoryToPath(memory, targetPath) {
     await this.writeMemoryFileAtomic(targetPath, memory);
-    const sourcePath = path7.resolve(memory.path);
-    const destPath = path7.resolve(targetPath);
+    const sourcePath = path8.resolve(memory.path);
+    const destPath = path8.resolve(targetPath);
     if (sourcePath !== destPath) {
       try {
         await unlink2(memory.path);
@@ -6846,8 +6870,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path7.resolve(memory.path);
-    const destPath = path7.resolve(targetPath);
+    const sourcePath = path8.resolve(memory.path);
+    const destPath = path8.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -6874,7 +6898,7 @@ ${memory.content}
     return { changed: true, targetPath };
   }
   get archiveDir() {
-    return path7.join(this.baseDir, "archive");
+    return path8.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -6885,7 +6909,7 @@ ${memory.content}
     try {
       const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
       const today = now.toISOString().slice(0, 10);
-      const destDir = path7.join(this.archiveDir, today);
+      const destDir = path8.join(this.archiveDir, today);
       await mkdir2(destDir, { recursive: true });
       const updatedFm = {
         ...memory.frontmatter,
@@ -6897,7 +6921,7 @@ ${memory.content}
 
 ${memory.content}
 `;
-      const destPath = path7.join(destDir, path7.basename(memory.path));
+      const destPath = path8.join(destDir, path8.basename(memory.path));
       await this.writeStorageSecureFile(destPath, fileContent);
       await unlink2(memory.path);
       markProjectedMemoryPathInvalid(this.baseDir, memory.frontmatter.id);
@@ -7045,7 +7069,7 @@ ${memory.content}
 `;
     await this.writeStorageSecureFile(memory.path, fileContent);
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path7.sep}cold${path7.sep}`)) {
+    if (memory.path.includes(`${path8.sep}cold${path8.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -7116,7 +7140,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path7.join(this.stateDir, "buffer.json");
+    const bufferPath = path8.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -7128,11 +7152,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path7.join(this.stateDir, "buffer.json");
+    const bufferPath = path8.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path7.join(this.stateDir, "meta.json");
+    const metaPath = path8.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -7165,7 +7189,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path7.join(this.stateDir, "meta.json");
+    const metaPath = path8.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -7232,7 +7256,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir2(path7.dirname(target), { recursive: true });
+        await mkdir2(path8.dirname(target), { recursive: true });
       }
     );
   }
@@ -7330,7 +7354,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path7.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path8.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -7343,7 +7367,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path7.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path8.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -7573,7 +7597,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path7.join(this.questionsDir, `${id}.md`);
+    const filePath = path8.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -7591,7 +7615,7 @@ ${question}
     if (!match) return null;
     const frontmatterStr = match[1];
     const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path7.basename(filePath, ".md");
+    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path8.basename(filePath, ".md");
     const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
     const priority = parseFloat(this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5");
     const resolved = this.extractFrontmatterValue(frontmatterStr, "resolved") === "true";
@@ -7647,11 +7671,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path7.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path8.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path7.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path8.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -7747,7 +7771,7 @@ ${reflection}
    * Deduplicates by target+label.
    */
   async addEntityRelationship(name, rel) {
-    const filePath = path7.join(this.entitiesDir, `${name}.md`);
+    const filePath = path8.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -7770,7 +7794,7 @@ ${reflection}
    * Prepends to the beginning, prunes oldest entries beyond maxEntries.
    */
   async addEntityActivity(name, entry, maxEntries) {
-    const filePath = path7.join(this.entitiesDir, `${name}.md`);
+    const filePath = path8.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -7793,7 +7817,7 @@ ${reflection}
    * Add an alias to an entity file. Deduplicates.
    */
   async addEntityAlias(name, alias) {
-    const filePath = path7.join(this.entitiesDir, `${name}.md`);
+    const filePath = path8.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -7820,7 +7844,7 @@ ${reflection}
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     let synthesisTimelineCount;
     try {
-      const filePath = path7.join(this.entitiesDir, `${name}.md`);
+      const filePath = path8.join(this.entitiesDir, `${name}.md`);
       const content = await this.readStorageSecureFile(filePath);
       synthesisTimelineCount = parseEntityFile(content, this.entitySchemas).timeline.length;
     } catch (err) {
@@ -7903,7 +7927,7 @@ ${reflection}
       if (!raw) continue;
       const serialized = serializeEntityFile(parseEntityFile(raw, this.entitySchemas), this.entitySchemas);
       if (raw.trimEnd() === serialized.trimEnd()) continue;
-      await this.writeStorageSecureFile(path7.join(this.entitiesDir, `${entityName}.md`), serialized);
+      await this.writeStorageSecureFile(path8.join(this.entitiesDir, `${entityName}.md`), serialized);
       migrated += 1;
     }
     if (migrated > 0) {
@@ -7996,14 +8020,14 @@ ${reflection}
     if (entries.length === 0) return 0;
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-    const memoryPathMap = new Map(memories.map((m) => [path7.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path8.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     const keyId = this.hotCacheKeyId();
     const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
     const appliedPatches = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      const memory = entry.memoryPath ? memoryPathMap.get(path7.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path8.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       const newFm = {
         ...memory.frontmatter,
@@ -8019,7 +8043,7 @@ ${memory.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...memory, frontmatter: newFm }, keyId);
         }
-        appliedPatches.set(path7.resolve(memory.path), {
+        appliedPatches.set(path8.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -8035,7 +8059,7 @@ ${memory.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path7.resolve(m.path));
+            const patch = appliedPatches.get(path8.resolve(m.path));
             return patch ? { ...m, frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed } } : m;
           });
           setCachedMemories(this.baseDir, reapplied, produced, keyId, this.hotCacheTtlMs());
@@ -8067,7 +8091,7 @@ ${memory.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path7.basename(filePath, ".md");
+      const memoryId = path8.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -8082,7 +8106,7 @@ ${memory.content}
           qmdResultPathCandidates(this.baseDir, preferredPath)
         );
         const directMatch = existingPaths.find(
-          (filePath) => directCandidates.has(path7.resolve(filePath))
+          (filePath) => directCandidates.has(path8.resolve(filePath))
         );
         if (directMatch) {
           preferredMatches.push(directMatch);
@@ -8095,7 +8119,7 @@ ${memory.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path7.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path8.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -8157,7 +8181,15 @@ ${memory.content}
     if (cappedLimit === 0) return [];
     const projected = readProjectedMemoryTimeline(this.baseDir, memoryId, cappedLimit);
     if (projected && projected.length > 0) return projected;
-    warnProjectionFallback(this.baseDir, "getMemoryTimeline");
+    warnProjectionFallback(this.baseDir, "getMemoryTimeline", () => {
+      const rebuiltAt = readProjectionRebuiltAt(this.baseDir);
+      if (!rebuiltAt) return "projection never rebuilt";
+      const ageMs = Date.now() - Date.parse(rebuiltAt);
+      if (!Number.isFinite(ageMs)) return `projection rebuiltAt=${rebuiltAt}`;
+      const ageMin = Math.max(0, Math.round(ageMs / 6e4));
+      const age = ageMin >= 120 ? `${Math.round(ageMin / 60)}h` : `${ageMin}m`;
+      return `projection ${age} stale, last rebuilt ${rebuiltAt}`;
+    });
     return readBoundedLifecycleEventsFromLedger(
       this.memoryLifecycleLedgerPath,
       (p) => this.readStorageSecureFile(p),
@@ -8306,14 +8338,14 @@ Reason: ${reason}`;
   // Memory Summarization (Phase 4A)
   // ---------------------------------------------------------------------------
   get summariesDir() {
-    return path7.join(this.baseDir, "summaries");
+    return path8.join(this.baseDir, "summaries");
   }
   /**
    * Write a memory summary.
    */
   async writeSummary(summary) {
     await mkdir2(this.summariesDir, { recursive: true });
-    const filePath = path7.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path8.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -8326,7 +8358,7 @@ Reason: ${reason}`;
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path7.join(this.summariesDir, file);
+        const filePath = path8.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -8388,7 +8420,7 @@ ${memory.content}
    * Save topic scores to meta.json.
    */
   async saveTopics(topics) {
-    const metaPath = path7.join(this.stateDir, "topics.json");
+    const metaPath = path8.join(this.stateDir, "topics.json");
     await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       metaPath,
@@ -8400,7 +8432,7 @@ ${memory.content}
    * Load topic scores from meta.json.
    */
   async loadTopics() {
-    const metaPath = path7.join(this.stateDir, "topics.json");
+    const metaPath = path8.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -8478,6 +8510,8 @@ ${memory.content}
 };
 
 export {
+  readProjectionRebuiltAt,
+  assertInjectedStorageRooted,
   selfDeps,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
@@ -8513,4 +8547,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-7YJLCNPF.js.map
+//# sourceMappingURL=chunk-HRREDJSL.js.map