@remnic/core 9.3.756 → 9.3.758

package/dist/{chunk-7APVFQ34.js → chunk-DUQHQ3TL.js}

@@ -28,6 +28,11 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
 } from "./chunk-JS2HKKOK.js";
+import {
+  getCachedEntities,
+  invalidateAllForDir,
+  setCachedEntities
+} from "./chunk-AWJ2FHCF.js";
 import {
   inferMemoryStatus,
   isArchivedMemoryPath,
@@ -45,10 +50,8 @@ import {
   readProjectedMemoryTimeline
 } from "./chunk-MB5RSUW6.js";
 import {
-  getCachedEntities,
-  invalidateAllForDir,
-  setCachedEntities
-} from "./chunk-AWJ2FHCF.js";
+  rotateMarkdownFileToArchive
+} from "./chunk-DM2T26WE.js";
 import {
   closeContinuityIncidentRecord,
   createContinuityIncidentRecord,
@@ -58,13 +61,13 @@ import {
   serializeContinuityIncident,
   upsertContinuityLoopInMarkdown
 } from "./chunk-LDXUBPMO.js";
-import {
-  rotateMarkdownFileToArchive
-} from "./chunk-DM2T26WE.js";
 import {
   parseFaithfulnessField,
   serializeFaithfulnessFields
-} from "./chunk-2OZ2JEUP.js";
+} from "./chunk-YTU7WKYN.js";
+import {
+  createVersion
+} from "./chunk-VF4XKTX3.js";
 import {
   computeContentHash,
   normalizeContent
@@ -73,9 +76,6 @@ import {
   isConsolidationOperator,
   isValidDerivedFromEntry
 } from "./chunk-G7D6GZ5J.js";
-import {
-  createVersion
-} from "./chunk-VF4XKTX3.js";
 import {
   parseProvenanceSources,
   parseProvenanceTag,
@@ -112,10 +112,10 @@ import {
 } from "./chunk-VS2IYZRU.js";
 
 // src/storage.ts
-import { access, readdir as readdir3, readFile, stat as stat2, writeFile, mkdir, unlink as unlink2, appendFile, open } from "fs/promises";
+import { access, readdir as readdir4, readFile, stat as stat2, writeFile, mkdir, unlink as unlink2, appendFile, open } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, readFileSync, statSync } from "fs";
 import { createHash } from "crypto";
-import path3 from "path";
+import path4 from "path";
 
 // src/storage/memory-read-store.ts
 import { lstat, readdir, realpath, stat } from "fs/promises";
@@ -1040,6 +1040,161 @@ ${rows.join("\n")}
   }
 };
 
+// src/storage/identity-continuity-store.ts
+import { readdir as readdir3 } from "fs/promises";
+import path3 from "path";
+var IdentityContinuityStore = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async writeIdentityAnchor(content) {
+    await this.deps.ensureDirectories();
+    await this.deps.writeStorageSecureFile(this.deps.identityAnchorPath, content);
+  }
+  async readIdentityAnchor() {
+    try {
+      return await this.deps.readStorageSecureFile(this.deps.identityAnchorPath);
+    } catch (err) {
+      if (!isErrnoCode(err, "ENOENT")) throw err;
+      return null;
+    }
+  }
+  async appendContinuityIncident(input) {
+    await this.deps.ensureDirectories();
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    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`);
+    await this.deps.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
+    return { ...incident, filePath };
+  }
+  async readContinuityIncidents(limit = 200, state = "all") {
+    const normalizedLimit = Number.isFinite(limit) ? Math.floor(limit) : 0;
+    const cappedLimit = Math.max(0, normalizedLimit);
+    if (cappedLimit === 0) return [];
+    try {
+      const candidates = await this.readContinuityIncidentFileNames();
+      const incidents = [];
+      for (const file of candidates) {
+        if (incidents.length >= cappedLimit) break;
+        const filePath = path3.join(this.deps.identityIncidentsDir, file);
+        try {
+          const raw = await this.deps.readStorageSecureFile(filePath);
+          const parsed = parseContinuityIncident(raw);
+          if (!parsed) continue;
+          if (state !== "all" && parsed.state !== state) continue;
+          incidents.push({ ...parsed, filePath });
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError) throw err;
+        }
+      }
+      return incidents;
+    } catch (err) {
+      if (err instanceof SecureStoreLockedError) throw err;
+      if (!isErrnoCode(err, "ENOENT")) throw err;
+      return [];
+    }
+  }
+  async closeContinuityIncident(id, closure) {
+    const directFilePath = await this.findContinuityIncidentFilePathById(id);
+    const target = directFilePath ? await this.readContinuityIncidentFile(directFilePath) : null;
+    if (!target || !directFilePath) return null;
+    if (target.state === "closed") return target;
+    const closed = closeContinuityIncidentRecord(target, closure, (/* @__PURE__ */ new Date()).toISOString());
+    await this.deps.writeStorageSecureFile(directFilePath, serializeContinuityIncident(closed));
+    return { ...closed, filePath: directFilePath };
+  }
+  async writeIdentityAudit(period, key, content) {
+    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`);
+    await this.deps.writeStorageSecureFile(filePath, content);
+    return filePath;
+  }
+  async readIdentityAudit(period, key) {
+    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`));
+    } catch (err) {
+      if (err instanceof Error && err.message === "Invalid identity audit key") return null;
+      if (!isErrnoCode(err, "ENOENT")) throw err;
+      return null;
+    }
+  }
+  async writeIdentityImprovementLoops(content) {
+    await this.deps.ensureDirectories();
+    await this.deps.writeStorageSecureFile(this.deps.identityImprovementLoopsPath, content);
+  }
+  async readIdentityImprovementLoops() {
+    try {
+      return await this.deps.readStorageSecureFile(this.deps.identityImprovementLoopsPath);
+    } catch (err) {
+      if (!isErrnoCode(err, "ENOENT")) throw err;
+      return null;
+    }
+  }
+  async readIdentityImprovementLoopRegister() {
+    const raw = await this.readIdentityImprovementLoops();
+    if (!raw) return [];
+    return parseContinuityImprovementLoops(raw);
+  }
+  async upsertIdentityImprovementLoop(input) {
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const raw = await this.readIdentityImprovementLoops();
+    const { markdown, loop } = upsertContinuityLoopInMarkdown(raw, input, nowIso);
+    await this.writeIdentityImprovementLoops(markdown);
+    return loop;
+  }
+  async reviewIdentityImprovementLoop(id, input) {
+    const raw = await this.readIdentityImprovementLoops();
+    const { markdown, loop } = reviewContinuityLoopInMarkdown(raw, id, input, (/* @__PURE__ */ new Date()).toISOString());
+    if (!loop) return null;
+    await this.writeIdentityImprovementLoops(markdown);
+    return loop;
+  }
+  async readContinuityIncidentFileNames() {
+    const files = await readdir3(this.deps.identityIncidentsDir);
+    return files.filter((file) => file.endsWith(".md")).sort().reverse();
+  }
+  async readContinuityIncidentFile(filePath) {
+    try {
+      const raw = await this.deps.readStorageSecureFile(filePath);
+      const parsed = parseContinuityIncident(raw);
+      return parsed ? { ...parsed, filePath } : null;
+    } catch (err) {
+      if (err instanceof SecureStoreLockedError) throw err;
+      return null;
+    }
+  }
+  async findContinuityIncidentFilePathById(id) {
+    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 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 parsed = await this.readContinuityIncidentFile(filePath);
+      if (parsed?.id === id) return filePath;
+    }
+    return null;
+  }
+  sanitizeIdentityAuditKey(key) {
+    const trimmed = key.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed) || trimmed.includes("..")) {
+      throw new Error("Invalid identity audit key");
+    }
+    return trimmed;
+  }
+};
+
 // src/storage.ts
 var ARTIFACT_SEARCH_STOPWORDS = /* @__PURE__ */ new Set([
   "a",
@@ -1645,17 +1800,17 @@ var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set([
   "topic"
 ]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path3.basename(pathRel, ".md").toLowerCase();
+  const basename = path4.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(path3.sep).join("/");
+  const normalizedPath = pathRel.split(path4.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path3.basename(pathRel, ".md");
+    const basename = path4.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -1722,8 +1877,8 @@ var ContentHashIndex = class _ContentHashIndex {
   secureStoreKeyProvider;
   secureStoreWriteKeyProvider;
   memoryDir;
-  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path3.dirname(stateDir)) {
-    this.filePath = path3.join(stateDir, "fact-hashes.txt");
+  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path4.dirname(stateDir)) {
+    this.filePath = path4.join(stateDir, "fact-hashes.txt");
     this.secureStoreKeyProvider = secureStoreKeyProvider;
     this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;
     this.memoryDir = memoryDir;
@@ -1770,7 +1925,7 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Persist index to disk if changed. */
   async save() {
     if (!this.dirty) return;
-    await mkdir(path3.dirname(this.filePath), { recursive: true });
+    await mkdir(path4.dirname(this.filePath), { recursive: true });
     await writeMaybeEncryptedFile(
       this.filePath,
       [...this.hashes].join("\n") + "\n",
@@ -2836,7 +2991,7 @@ var StorageManager3 = class _StorageManager {
         void 0,
         this.baseDir
       );
-      const rel = path3.relative(this.baseDir, filePath).split(path3.sep).join("/");
+      const rel = path4.relative(this.baseDir, filePath).split(path4.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -2878,18 +3033,28 @@ var StorageManager3 = class _StorageManager {
     }
     return this._entityStore;
   }
+  /** IdentityContinuityStore (storage.ts decomposition). Lazy; selfDeps live wiring. */
+  _identityContinuityStore;
+  get identityContinuityStore() {
+    if (!this._identityContinuityStore) {
+      this._identityContinuityStore = new IdentityContinuityStore(
+        selfDeps(this)
+      );
+    }
+    return this._identityContinuityStore;
+  }
   get dir() {
     return this.baseDir;
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path3.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path4.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path3.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path4.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
     const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : ".cold-write-version.log";
-    return path3.join(this.stateDir, fileName);
+    return path4.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -2936,7 +3101,7 @@ var StorageManager3 = class _StorageManager {
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path3.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path4.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -2954,7 +3119,7 @@ var StorageManager3 = class _StorageManager {
         `invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path3.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path4.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -3041,25 +3206,25 @@ var StorageManager3 = class _StorageManager {
     });
   }
   get factsDir() {
-    return path3.join(this.baseDir, "facts");
+    return path4.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path3.join(this.baseDir, "corrections");
+    return path4.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path3.join(this.baseDir, "procedures");
+    return path4.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path3.join(this.baseDir, "reasoning-traces");
+    return path4.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path3.join(this.baseDir, "entities");
+    return path4.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path3.resolve(this.entitiesDir, `${name}.md`);
-    const relative = path3.relative(this.entitiesDir, filePath);
-    if (relative === "" || relative.startsWith("..") || path3.isAbsolute(relative)) {
+    const filePath = path4.resolve(this.entitiesDir, `${name}.md`);
+    const relative = path4.relative(this.entitiesDir, filePath);
+    if (relative === "" || relative.startsWith("..") || path4.isAbsolute(relative)) {
       return null;
     }
     return filePath;
@@ -3074,10 +3239,10 @@ var StorageManager3 = class _StorageManager {
     return writeMaybeEncryptedFileFromChunks(filePath, chunks, this.resolveWriteKey(), {}, this.baseDir).then(() => this.notifyCatalogWrite());
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path3.resolve(filePath);
-    const base = path3.resolve(this.baseDir);
-    const rel = path3.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path3.sep}`) || path3.isAbsolute(rel)) {
+    const resolved = path4.resolve(filePath);
+    const base = path4.resolve(this.baseDir);
+    const rel = path4.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path4.sep}`) || path4.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -3089,7 +3254,7 @@ var StorageManager3 = class _StorageManager {
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat2(target);
-    const relPath = path3.relative(this.baseDir, target).split(path3.sep).join("/");
+    const relPath = path4.relative(this.baseDir, target).split(path4.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) {
@@ -3150,7 +3315,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("../") || path3.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("../") || path4.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 });
@@ -3192,7 +3357,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 mkdir(path3.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir(path4.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile(
         this.offlineSyncDigestCachePath,
         `${JSON.stringify({ version: 1, entries })}
@@ -3245,10 +3410,10 @@ var StorageManager3 = class _StorageManager {
       if (isErrnoCode(error, "ENOENT")) return;
       throw error;
     });
-    if (filePath.includes(`${path3.sep}cold${path3.sep}`)) {
+    if (filePath.includes(`${path4.sep}cold${path4.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
-    if (filePath.includes(`${path3.sep}artifacts${path3.sep}`)) {
+    if (filePath.includes(`${path4.sep}artifacts${path4.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
     this.bumpMemoryStatusVersion();
@@ -3276,7 +3441,7 @@ var StorageManager3 = class _StorageManager {
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir(path3.dirname(filePath), { recursive: true });
+    await mkdir(path4.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (isEncryptedFile(await readFile(filePath))) {
@@ -3302,16 +3467,16 @@ var StorageManager3 = class _StorageManager {
     this.notifyCatalogWrite();
   }
   get stateDir() {
-    return path3.join(this.baseDir, "state");
+    return path4.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path3.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path4.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path3.join(this.stateDir, "entity-synthesis-queue.json");
+    return path4.join(this.stateDir, "entity-synthesis-queue.json");
   }
   get factHashIndexReadyPath() {
-    return path3.join(this.stateDir, "fact-hashes.ready");
+    return path4.join(this.stateDir, "fact-hashes.ready");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -3321,7 +3486,7 @@ var StorageManager3 = class _StorageManager {
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path3.join(this.stateDir, "tombstones.jsonl");
+    return path4.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -3520,7 +3685,7 @@ var StorageManager3 = class _StorageManager {
         );
       }
       await factHashIndex.save();
-      await mkdir(path3.dirname(this.factHashIndexReadyPath), { recursive: true });
+      await mkdir(path4.dirname(this.factHashIndexReadyPath), { recursive: true });
       await writeFile(this.factHashIndexReadyPath, "v1\n", "utf-8");
       this.factHashIndexAuthoritative = true;
     })().finally(() => {
@@ -3529,55 +3694,55 @@ var StorageManager3 = class _StorageManager {
     await this.factHashIndexAuthoritativePromise;
   }
   get questionsDir() {
-    return path3.join(this.baseDir, "questions");
+    return path4.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path3.join(this.baseDir, "artifacts");
+    return path4.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path3.join(this.baseDir, "identity");
+    return path4.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path3.join(this.identityDir, "identity-anchor.md");
+    return path4.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path3.join(this.identityDir, "incidents");
+    return path4.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path3.join(this.identityDir, "audits", "weekly");
+    return path4.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path3.join(this.identityDir, "audits", "monthly");
+    return path4.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path3.join(this.identityDir, "improvement-loops.md");
+    return path4.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path3.join(this.identityDir, "reflections.md");
+    return path4.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path3.join(this.baseDir, "profile.md");
+    return path4.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path3.join(this.stateDir, "memory-actions.jsonl");
+    return path4.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path3.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path4.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path3.join(this.stateDir, "compression-guidelines.md");
+    return path4.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path3.join(this.stateDir, "compression-guidelines.draft.md");
+    return path4.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path3.join(this.stateDir, "compression-guideline-state.json");
+    return path4.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path3.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path4.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path3.join(this.stateDir, "behavior-signals.jsonl");
+    return path4.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * Buffer surprise telemetry ledger (issue #563 PR 3).
@@ -3590,7 +3755,7 @@ var StorageManager3 = class _StorageManager {
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path3.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path4.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -3624,7 +3789,7 @@ var StorageManager3 = class _StorageManager {
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path3.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path4.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     try {
       const raw = readFileSync(aliasPath, "utf-8");
@@ -3649,9 +3814,9 @@ var StorageManager3 = class _StorageManager {
   }
   async ensureDirectories() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir(path3.join(this.factsDir, today), { recursive: true });
-    await mkdir(path3.join(this.proceduresDir, today), { recursive: true });
-    await mkdir(path3.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir(path4.join(this.factsDir, today), { recursive: true });
+    await mkdir(path4.join(this.proceduresDir, today), { recursive: true });
+    await mkdir(path4.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir(this.correctionsDir, { recursive: true });
     await mkdir(this.entitiesDir, { recursive: true });
     await mkdir(this.stateDir, { recursive: true });
@@ -3661,7 +3826,7 @@ var StorageManager3 = class _StorageManager {
     await mkdir(this.identityIncidentsDir, { recursive: true });
     await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir(path3.join(this.baseDir, "config"), { recursive: true });
+    await mkdir(path4.join(this.baseDir, "config"), { recursive: true });
   }
   /**
    * Resolve the on-disk write path for a memory of the given category, creating
@@ -3678,11 +3843,11 @@ var StorageManager3 = class _StorageManager {
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir(this.correctionsDir, { recursive: true });
-      return path3.join(this.correctionsDir, `${id}.md`);
+      return path4.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path3.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path4.join(getCategoryDir(this.baseDir, category), today);
     await mkdir(datedDir, { recursive: true });
-    return path3.join(datedDir, `${id}.md`);
+    return path4.join(datedDir, `${id}.md`);
   }
   async writeMemory(category, content, options = {}) {
     await this.ensureDirectories();
@@ -3932,7 +4097,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path3.join(this.artifactsDir, day);
+    const dir = path4.join(this.artifactsDir, day);
     await mkdir(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -3956,7 +4121,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path3.join(dir, `${id}.md`);
+    const filePath = path4.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
@@ -4158,7 +4323,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path3.join(this.baseDir, "cold");
+    const coldRoot = path4.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -4248,7 +4413,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path3.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path4.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -4311,9 +4476,9 @@ ${sanitized.text}
     const root = this.archiveDir;
     const readDir = async (dir) => {
       try {
-        const entries = await readdir3(dir, { withFileTypes: true });
+        const entries = await readdir4(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path3.join(dir, entry.name);
+          const fullPath = path4.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -4348,7 +4513,7 @@ ${sanitized.text}
     );
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path3.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path4.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -4363,13 +4528,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path3.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path4.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path3.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path4.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path3.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path4.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     const fileContent = `${serializeFrontmatter(memory.frontmatter)}
@@ -4382,8 +4547,8 @@ ${memory.content}
   }
   async moveMemoryToPath(memory, targetPath) {
     await this.writeMemoryFileAtomic(targetPath, memory);
-    const sourcePath = path3.resolve(memory.path);
-    const destPath = path3.resolve(targetPath);
+    const sourcePath = path4.resolve(memory.path);
+    const destPath = path4.resolve(targetPath);
     if (sourcePath !== destPath) {
       try {
         await unlink2(memory.path);
@@ -4398,8 +4563,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path3.resolve(memory.path);
-    const destPath = path3.resolve(targetPath);
+    const sourcePath = path4.resolve(memory.path);
+    const destPath = path4.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -4425,7 +4590,7 @@ ${memory.content}
     return { changed: true, targetPath };
   }
   get archiveDir() {
-    return path3.join(this.baseDir, "archive");
+    return path4.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -4436,7 +4601,7 @@ ${memory.content}
     try {
       const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
       const today = now.toISOString().slice(0, 10);
-      const destDir = path3.join(this.archiveDir, today);
+      const destDir = path4.join(this.archiveDir, today);
       await mkdir(destDir, { recursive: true });
       const updatedFm = {
         ...memory.frontmatter,
@@ -4448,7 +4613,7 @@ ${memory.content}
 
 ${memory.content}
 `;
-      const destPath = path3.join(destDir, path3.basename(memory.path));
+      const destPath = path4.join(destDir, path4.basename(memory.path));
       await this.writeStorageSecureFile(destPath, fileContent);
       await unlink2(memory.path);
       this.invalidateAllMemoriesCache();
@@ -4477,7 +4642,7 @@ ${memory.content}
   }
   async readEntities() {
     try {
-      const entries = await readdir3(this.entitiesDir);
+      const entries = await readdir4(this.entitiesDir);
       return entries.filter((e) => e.endsWith(".md")).map((e) => e.replace(".md", ""));
     } catch {
       return [];
@@ -4596,7 +4761,7 @@ ${memory.content}
 `;
     await this.writeStorageSecureFile(memory.path, fileContent);
     this.invalidateAllMemoriesCache();
-    if (memory.path.includes(`${path3.sep}cold${path3.sep}`)) {
+    if (memory.path.includes(`${path4.sep}cold${path4.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -4668,7 +4833,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path3.join(this.stateDir, "buffer.json");
+    const bufferPath = path4.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -4680,11 +4845,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path3.join(this.stateDir, "buffer.json");
+    const bufferPath = path4.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path3.join(this.stateDir, "meta.json");
+    const metaPath = path4.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -4718,7 +4883,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path3.join(this.stateDir, "meta.json");
+    const metaPath = path4.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -4804,7 +4969,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path3.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path4.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -4817,7 +4982,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path3.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path4.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -5009,113 +5174,40 @@ ${memory.content}
     );
   }
   async writeIdentityAnchor(content) {
-    await this.ensureDirectories();
-    await this.writeStorageSecureFile(this.identityAnchorPath, content);
+    return this.identityContinuityStore.writeIdentityAnchor(content);
   }
   async readIdentityAnchor() {
-    try {
-      return await this.readStorageSecureFile(this.identityAnchorPath);
-    } catch (err) {
-      if (!isErrnoCode(err, "ENOENT")) throw err;
-      return null;
-    }
+    return this.identityContinuityStore.readIdentityAnchor();
   }
   async appendContinuityIncident(input) {
-    await this.ensureDirectories();
-    const now = /* @__PURE__ */ new Date();
-    const nowIso = now.toISOString();
-    const date = nowIso.slice(0, 10);
-    const id = this.generateId("incident");
-    const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path3.join(this.identityIncidentsDir, `${date}-${id}.md`);
-    await this.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
-    return { ...incident, filePath };
+    return this.identityContinuityStore.appendContinuityIncident(input);
   }
   async readContinuityIncidents(limit = 200, state = "all") {
-    const normalizedLimit = Number.isFinite(limit) ? Math.floor(limit) : 0;
-    const cappedLimit = Math.max(0, normalizedLimit);
-    if (cappedLimit === 0) return [];
-    try {
-      const candidates = await this.readContinuityIncidentFileNames();
-      const incidents = [];
-      for (const file of candidates) {
-        if (incidents.length >= cappedLimit) break;
-        const filePath = path3.join(this.identityIncidentsDir, file);
-        try {
-          const raw = await this.readStorageSecureFile(filePath);
-          const parsed = parseContinuityIncident(raw);
-          if (!parsed) continue;
-          if (state !== "all" && parsed.state !== state) continue;
-          incidents.push({ ...parsed, filePath });
-        } catch (err) {
-          if (err instanceof SecureStoreLockedError) throw err;
-        }
-      }
-      return incidents;
-    } catch (err) {
-      if (err instanceof SecureStoreLockedError) throw err;
-      if (!isErrnoCode(err, "ENOENT")) throw err;
-      return [];
-    }
+    return this.identityContinuityStore.readContinuityIncidents(limit, state);
   }
   async closeContinuityIncident(id, closure) {
-    const directFilePath = await this.findContinuityIncidentFilePathById(id);
-    const target = directFilePath ? await this.readContinuityIncidentFile(directFilePath) : null;
-    if (!target || !directFilePath) return null;
-    if (target.state === "closed") return target;
-    const closed = closeContinuityIncidentRecord(target, closure, (/* @__PURE__ */ new Date()).toISOString());
-    await this.writeStorageSecureFile(directFilePath, serializeContinuityIncident(closed));
-    return { ...closed, filePath: directFilePath };
+    return this.identityContinuityStore.closeContinuityIncident(id, closure);
   }
   async writeIdentityAudit(period, key, content) {
-    await this.ensureDirectories();
-    const safeKey = this.sanitizeIdentityAuditKey(key);
-    const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
-    const filePath = path3.join(dir, `${safeKey}.md`);
-    await this.writeStorageSecureFile(filePath, content);
-    return filePath;
+    return this.identityContinuityStore.writeIdentityAudit(period, key, content);
   }
   async readIdentityAudit(period, key) {
-    try {
-      const safeKey = this.sanitizeIdentityAuditKey(key);
-      const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
-      return await this.readStorageSecureFile(path3.join(dir, `${safeKey}.md`));
-    } catch (err) {
-      if (err instanceof Error && err.message === "Invalid identity audit key") return null;
-      if (!isErrnoCode(err, "ENOENT")) throw err;
-      return null;
-    }
+    return this.identityContinuityStore.readIdentityAudit(period, key);
   }
   async writeIdentityImprovementLoops(content) {
-    await this.ensureDirectories();
-    await this.writeStorageSecureFile(this.identityImprovementLoopsPath, content);
+    return this.identityContinuityStore.writeIdentityImprovementLoops(content);
   }
   async readIdentityImprovementLoops() {
-    try {
-      return await this.readStorageSecureFile(this.identityImprovementLoopsPath);
-    } catch (err) {
-      if (!isErrnoCode(err, "ENOENT")) throw err;
-      return null;
-    }
+    return this.identityContinuityStore.readIdentityImprovementLoops();
   }
   async readIdentityImprovementLoopRegister() {
-    const raw = await this.readIdentityImprovementLoops();
-    if (!raw) return [];
-    return parseContinuityImprovementLoops(raw);
+    return this.identityContinuityStore.readIdentityImprovementLoopRegister();
   }
   async upsertIdentityImprovementLoop(input) {
-    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-    const raw = await this.readIdentityImprovementLoops();
-    const { markdown, loop } = upsertContinuityLoopInMarkdown(raw, input, nowIso);
-    await this.writeIdentityImprovementLoops(markdown);
-    return loop;
+    return this.identityContinuityStore.upsertIdentityImprovementLoop(input);
   }
   async reviewIdentityImprovementLoop(id, input) {
-    const raw = await this.readIdentityImprovementLoops();
-    const { markdown, loop } = reviewContinuityLoopInMarkdown(raw, id, input, (/* @__PURE__ */ new Date()).toISOString());
-    if (!loop) return null;
-    await this.writeIdentityImprovementLoops(markdown);
-    return loop;
+    return this.identityContinuityStore.reviewIdentityImprovementLoop(id, input);
   }
   // ---------------------------------------------------------------------------
   // Question storage
@@ -5125,42 +5217,6 @@ ${memory.content}
     const rand = Math.random().toString(36).slice(2, 4);
     return `${prefix}-${ts}-${rand}`;
   }
-  async readContinuityIncidentFileNames() {
-    const files = await readdir3(this.identityIncidentsDir);
-    return files.filter((file) => file.endsWith(".md")).sort().reverse();
-  }
-  async readContinuityIncidentFile(filePath) {
-    try {
-      const raw = await this.readStorageSecureFile(filePath);
-      const parsed = parseContinuityIncident(raw);
-      return parsed ? { ...parsed, filePath } : null;
-    } catch (err) {
-      if (err instanceof SecureStoreLockedError) throw err;
-      return null;
-    }
-  }
-  async findContinuityIncidentFilePathById(id) {
-    const fileNames = await this.readContinuityIncidentFileNames();
-    const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
-    if (directMatch) {
-      const directPath = path3.join(this.identityIncidentsDir, directMatch);
-      const parsed = await this.readContinuityIncidentFile(directPath);
-      if (parsed?.id === id) return directPath;
-    }
-    for (const fileName of fileNames) {
-      const filePath = path3.join(this.identityIncidentsDir, fileName);
-      const parsed = await this.readContinuityIncidentFile(filePath);
-      if (parsed?.id === id) return filePath;
-    }
-    return null;
-  }
-  sanitizeIdentityAuditKey(key) {
-    const trimmed = key.trim();
-    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed) || trimmed.includes("..")) {
-      throw new Error("Invalid identity audit key");
-    }
-    return trimmed;
-  }
   async writeQuestion(question, context, priority) {
     await mkdir(this.questionsDir, { recursive: true });
     const id = this.generateId("q");
@@ -5178,7 +5234,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path3.join(this.questionsDir, `${id}.md`);
+    const filePath = path4.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -5198,7 +5254,7 @@ ${question}
     if (!match) return null;
     const frontmatterStr = match[1];
     const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path3.basename(filePath, ".md");
+    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path4.basename(filePath, ".md");
     const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
     const priority = parseFloat(
       this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5"
@@ -5260,11 +5316,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path3.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path4.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path3.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path4.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -5358,7 +5414,7 @@ ${reflection}
    * Deduplicates by target+label.
    */
   async addEntityRelationship(name, rel) {
-    const filePath = path3.join(this.entitiesDir, `${name}.md`);
+    const filePath = path4.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -5383,7 +5439,7 @@ ${reflection}
    * Prepends to the beginning, prunes oldest entries beyond maxEntries.
    */
   async addEntityActivity(name, entry, maxEntries) {
-    const filePath = path3.join(this.entitiesDir, `${name}.md`);
+    const filePath = path4.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -5406,7 +5462,7 @@ ${reflection}
    * Add an alias to an entity file. Deduplicates.
    */
   async addEntityAlias(name, alias) {
-    const filePath = path3.join(this.entitiesDir, `${name}.md`);
+    const filePath = path4.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -5437,7 +5493,7 @@ ${reflection}
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     let synthesisTimelineCount;
     try {
-      const filePath = path3.join(this.entitiesDir, `${name}.md`);
+      const filePath = path4.join(this.entitiesDir, `${name}.md`);
       const content = await this.readStorageSecureFile(filePath);
       synthesisTimelineCount = parseEntityFile(content, this.entitySchemas).timeline.length;
     } catch (err) {
@@ -5520,7 +5576,7 @@ ${reflection}
       if (!raw) continue;
       const serialized = serializeEntityFile(parseEntityFile(raw, this.entitySchemas), this.entitySchemas);
       if (raw.trimEnd() === serialized.trimEnd()) continue;
-      await this.writeStorageSecureFile(path3.join(this.entitiesDir, `${entityName}.md`), serialized);
+      await this.writeStorageSecureFile(path4.join(this.entitiesDir, `${entityName}.md`), serialized);
       migrated += 1;
     }
     if (migrated > 0) {
@@ -5663,7 +5719,7 @@ ${memory.content}
     const filePaths = await this.collectActiveMemoryPaths();
     const foundIds = /* @__PURE__ */ new Set();
     for (const filePath of filePaths) {
-      const basename = path3.basename(filePath, ".md");
+      const basename = path4.basename(filePath, ".md");
       if (wantedIds.has(basename)) {
         foundIds.add(basename);
         if (foundIds.size === wantedIds.size) break;
@@ -5853,14 +5909,14 @@ Reason: ${reason}`, {
   // Memory Summarization (Phase 4A)
   // ---------------------------------------------------------------------------
   get summariesDir() {
-    return path3.join(this.baseDir, "summaries");
+    return path4.join(this.baseDir, "summaries");
   }
   /**
    * Write a memory summary.
    */
   async writeSummary(summary) {
     await mkdir(this.summariesDir, { recursive: true });
-    const filePath = path3.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path4.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -5869,11 +5925,11 @@ Reason: ${reason}`, {
    */
   async readSummaries() {
     try {
-      const files = await readdir3(this.summariesDir);
+      const files = await readdir4(this.summariesDir);
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path3.join(this.summariesDir, file);
+        const filePath = path4.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -5934,7 +5990,7 @@ ${memory.content}
    * Save topic scores to meta.json.
    */
   async saveTopics(topics) {
-    const metaPath = path3.join(this.stateDir, "topics.json");
+    const metaPath = path4.join(this.stateDir, "topics.json");
     await mkdir(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(metaPath, JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
     log.debug(`saved ${topics.length} topic scores`);
@@ -5943,7 +5999,7 @@ ${memory.content}
    * Load topic scores from meta.json.
    */
   async loadTopics() {
-    const metaPath = path3.join(this.stateDir, "topics.json");
+    const metaPath = path4.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -6040,4 +6096,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-7APVFQ34.js.map
+//# sourceMappingURL=chunk-DUQHQ3TL.js.map