@remnic/core 10.0.59 → 10.0.61

package/dist/{chunk-WXBVGKS6.js → chunk-N7RAABFM.js}

@@ -19,11 +19,14 @@ import {
   getFingerprint,
   migrateLegacyEntityCanonicalIds,
   validateRoots
-} from "./chunk-G6A3SGCE.js";
+} from "./chunk-WVEEVYMH.js";
+import {
+  BufferSessionFiles
+} from "./chunk-JCL7RO2G.js";
 import {
   normalizeQmdResultPath,
   resolveNamespaceResultPath
-} from "./chunk-JEX2JL3U.js";
+} from "./chunk-OH55F76C.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -34,13 +37,13 @@ import {
 import {
   parseOfflineSyncDigestCache
 } from "./chunk-X3724WL4.js";
-import {
-  createMemorySnapshot
-} from "./chunk-S2HLHAZ4.js";
 import {
   rewriteProjectedEntityReferences,
   rewriteProjectedMemoryEntityReference
 } from "./chunk-MRPOZBJC.js";
+import {
+  createMemorySnapshot
+} from "./chunk-S2HLHAZ4.js";
 import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
@@ -76,6 +79,9 @@ import {
   normalizeEntityStructuredSection,
   sortStructuredSectionsBySchema
 } from "./chunk-ZIKENA2C.js";
+import {
+  normalizeEntityName
+} from "./chunk-YXZG5TVN.js";
 import {
   OKF_QUESTION_TYPE,
   assertNotOkfReservedBasename,
@@ -88,15 +94,15 @@ import {
   normalizeProjectionPreview,
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
-import {
-  normalizeEntityName
-} from "./chunk-YXZG5TVN.js";
 import {
   detectLanguageHint
 } from "./chunk-3WU7XOFN.js";
 import {
   checkCorpusReadAbort
 } from "./chunk-P4GUQSK3.js";
+import {
+  corpusScanWorker
+} from "./chunk-4LZ7SVKM.js";
 import {
   createVersion
 } from "./chunk-564YP3DW.js";
@@ -286,19 +292,19 @@ import {
 
 // src/storage.ts
 import {
-  lstat as lstat5,
-  readdir as readdir7,
+  lstat as lstat4,
+  readdir as readdir6,
   readFile,
-  realpath as realpath3,
+  realpath as realpath2,
   stat as stat3,
   writeFile as writeFile2,
   mkdir as mkdir2,
-  unlink as unlink5,
+  unlink as unlink4,
   appendFile,
   open
 } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, statSync as statSync2 } from "fs";
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/preferences/drift-types.ts
 function serializeDriftProvenance(fm) {
@@ -322,7 +328,7 @@ function parseDriftProvenance(fm) {
 }
 
 // src/storage.ts
-import path16 from "path";
+import path15 from "path";
 
 // src/storage/tombstone-migration-sources.ts
 import { statSync } from "fs";
@@ -384,7 +390,7 @@ function createTombstoneMigrationSourceContents(deps) {
 }
 
 // src/storage/memory-read-store.ts
-import { lstat, readdir, realpath, stat as stat2 } from "fs/promises";
+import { readdir, stat as stat2 } from "fs/promises";
 import path3 from "path";
 
 // src/storage/memory-frontmatter-metadata.ts
@@ -452,10 +458,6 @@ function orderWindowMemories(memories, baseDir) {
 }
 
 // src/storage/memory-read-store.ts
-function isPropagatableReadError(err) {
-  const code = err.code;
-  return typeof code === "string" && code !== "ENOENT";
-}
 function isStoreEntityMarkdown(baseDir, filePath) {
   if (!filePath.endsWith(".md")) return false;
   const relative2 = path3.relative(baseDir, filePath);
@@ -562,67 +564,24 @@ var MemoryReadStore = class {
    * escape: a category dir symlinked outside memoryDir (e.g. decisions/ -> an
    * external dir) must NOT pull out-of-store files into a scan (info leak).
    *
-   * Containment is established once, not per file: the memory root is resolved
-   * with a single `realpath`, every directory the walk enters is `lstat`ed (a
-   * symlinked or non-directory entry is never followed), and the entry TYPE
-   * comes from `readdir(withFileTypes)` — so a symlinked entry, file or
-   * directory, is skipped without a per-entry `realpath`. The old per-entry
-   * `realpath` cost one syscall per markdown file (hundreds of thousands per
-   * corpus scan) to re-derive a fact the directory-level checks already
-   * establish; reads refuse symlinked files at open time with `O_NOFOLLOW`, so
-   * a path swapped to a symlink mid-scan is refused rather than followed.
+   * The walk runs in the corpus-scan worker: it is one `readdir` + `lstat` per
+   * directory over the whole corpus, and on the main event loop that starves
+   * observe, recall and the extraction queue behind it. The implementation is
+   * shared (src/corpus-scan.ts) and the host runs it inline when no worker
+   * can start, so the collected path set is the same either way.
    * Paths only — no frontmatter parse.
    */
   async collectContainedMarkdownPaths(startDirs, propagateReadErrors = false, options) {
-    const filePaths = [];
-    try {
-      await realpath(this.deps.baseDir);
-    } catch (err) {
-      if (propagateReadErrors && isPropagatableReadError(err)) throw err;
-      return filePaths;
-    }
-    const collectPaths = async (dir) => {
-      checkCorpusReadAbort(options);
-      let dirStat;
-      try {
-        dirStat = await lstat(dir);
-      } catch (err) {
-        if (propagateReadErrors && isPropagatableReadError(err)) throw err;
-        return;
-      }
-      if (dirStat.isSymbolicLink()) return;
-      if (!dirStat.isDirectory()) {
-        if (propagateReadErrors) {
-          throw new Error(`corpus scan: expected a directory but found a non-directory at ${dir}`);
-        }
-        return;
-      }
-      let entries;
-      try {
-        entries = await readdir(dir, { withFileTypes: true });
-      } catch (err) {
-        if (propagateReadErrors && isPropagatableReadError(err)) throw err;
-        return;
-      }
-      const subdirs = [];
-      for (const entry of entries) {
-        checkCorpusReadAbort(options);
-        if (entry.isSymbolicLink()) continue;
-        if (isMacOsReplicationJunkBasename(entry.name)) continue;
-        const fullPath = path3.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          subdirs.push(fullPath);
-        } else if (entry.name.endsWith(".md")) {
-          filePaths.push(fullPath);
-        }
-      }
-      for (const subdir of subdirs) {
-        await collectPaths(subdir);
-      }
-    };
-    for (const dir of startDirs) {
-      await collectPaths(dir);
-    }
+    checkCorpusReadAbort(options);
+    const filePaths = await corpusScanWorker.request(
+      {
+        kind: "walk",
+        baseDir: this.deps.baseDir,
+        startDirs: [...startDirs],
+        propagateReadErrors
+      },
+      options?.abortSignal
+    );
     checkCorpusReadAbort(options);
     return filePaths;
   }
@@ -1772,7 +1731,7 @@ import { lstat as lstat3, readdir as readdir2, unlink } from "fs/promises";
 import path6 from "path";
 
 // src/storage/entity-migration-completion-cache.ts
-import { lstat as lstat2, realpath as realpath2 } from "fs/promises";
+import { lstat as lstat2, realpath } from "fs/promises";
 import path5 from "path";
 async function isTrustedEntitiesRoot(baseDir, entitiesDir) {
   let rootStat;
@@ -1786,8 +1745,8 @@ async function isTrustedEntitiesRoot(baseDir, entitiesDir) {
   let memoryRoot;
   let entitiesReal;
   try {
-    memoryRoot = await realpath2(baseDir);
-    entitiesReal = await realpath2(entitiesDir);
+    memoryRoot = await realpath(baseDir);
+    entitiesReal = await realpath(entitiesDir);
   } catch (err) {
     if (isErrnoCode(err, "ENOENT")) return false;
     throw err;
@@ -3084,7 +3043,7 @@ var EntityCanonicalIdMigrationRunner = class {
       await this.ensure();
       return;
     }
-    const { readSafeEntityEntries } = await import("./entity-canonical-id-migration-F3JVG6K6.js");
+    const { readSafeEntityEntries } = await import("./entity-canonical-id-migration-CUDCKWPF.js");
     await readSafeEntityEntries(entitiesDir);
   }
   /**
@@ -5001,209 +4960,13 @@ var MeetingRecordStore = class {
 };
 var SORT_STR = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 
-// src/storage/buffer-session-files.ts
-import { createHash as createHash4 } from "crypto";
-import { lstat as lstat4, readdir as readdir5, unlink as unlink4 } from "fs/promises";
-import path13 from "path";
-function isMissing(err) {
-  return err?.code === "ENOENT";
-}
-function asFsError(err) {
-  return err;
-}
-function bufferSessionFileName(key) {
-  return `s-${createHash4("sha256").update(key).digest("hex")}.json`;
-}
-function legacyStateToEntries(state) {
-  const entries = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(state.entries ?? {})) {
-    if (value && Array.isArray(value.turns)) entries.set(key, value);
-  }
-  if (!entries.has("default")) {
-    entries.set("default", {
-      turns: Array.isArray(state.turns) ? state.turns : [],
-      lastExtractionAt: state.lastExtractionAt ?? null,
-      extractionCount: Number.isFinite(state.extractionCount) ? state.extractionCount : 0
-    });
-  }
-  return entries;
-}
-function entryFromBody(body) {
-  if (!body || !Array.isArray(body.turns) || (body.key?.length ?? 0) === 0) return null;
-  const entry = {
-    turns: body.turns,
-    lastExtractionAt: body.lastExtractionAt ?? null,
-    extractionCount: Number.isFinite(body.extractionCount) ? Number(body.extractionCount) : 0
-  };
-  if (Array.isArray(body.retainedTurns)) entry.retainedTurns = body.retainedTurns;
-  return { key: String(body.key), entry };
-}
-var BufferSessionFiles = class {
-  constructor(stateDir, io) {
-    this.stateDir = stateDir;
-    this.io = io;
-  }
-  stateDir;
-  io;
-  dirVerified = false;
-  get dir() {
-    return path13.join(this.stateDir, "buffer");
-  }
-  fileFor(key) {
-    return path13.join(this.dir, bufferSessionFileName(key));
-  }
-  /**
-   * Refuse a symlinked buffer directory: following it would send buffered
-   * conversation data (and deletions) outside the memory root. One lstat of
-   * one directory, cached after it passes, so the observe path pays nothing
-   * per write; the cache is dropped on any failure.
-   */
-  async assertDirSafe() {
-    if (this.dirVerified) return;
-    let stat4 = null;
-    try {
-      stat4 = await lstat4(this.dir);
-    } catch (err) {
-      if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;
-    }
-    if (stat4 && (stat4.isSymbolicLink() || !stat4.isDirectory())) {
-      throw new Error(`buffer session directory must be a real directory, not a symlink or file: ${this.dir}`);
-    }
-    this.dirVerified = stat4 !== null;
-  }
-  /** Persist ONE session atomically. Compact JSON: machine-read state, and
-   * pretty-printing a large buffer costs CPU and bytes on every observe. */
-  async save(key, entry) {
-    await this.assertDirSafe();
-    await this.io.write(this.fileFor(key), JSON.stringify({ key, ...entry }));
-  }
-  /** Remove one session's file. Idempotent: an absent file is fine. */
-  async remove(key) {
-    await this.assertDirSafe();
-    try {
-      await unlink4(this.fileFor(key));
-    } catch (err) {
-      if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;
-    }
-  }
-  async listFiles() {
-    await this.assertDirSafe();
-    try {
-      const dirents = await readdir5(this.dir, { withFileTypes: true });
-      return dirents.filter((d) => d.isFile() && d.name.endsWith(".json")).map((d) => d.name);
-    } catch (err) {
-      if (err instanceof Error && isMissing(asFsError(err))) return [];
-      throw err;
-    }
-  }
-  /** Read every per-session file. Corrupt files are skipped (and logged) so
-   * one bad file cannot nuke the other sessions' buffered turns. */
-  async readAll() {
-    const names = await this.listFiles();
-    const entries = /* @__PURE__ */ new Map();
-    for (const name of names) {
-      try {
-        const body = JSON.parse(await this.io.read(path13.join(this.dir, name)));
-        const parsed = entryFromBody(body);
-        if (!parsed) throw new Error("invalid buffer session file shape");
-        if (entries.has(parsed.key)) {
-          log.warn(`buffer: duplicate session file for key ${parsed.key} (${name}); keeping the first`);
-          continue;
-        }
-        entries.set(parsed.key, parsed.entry);
-      } catch (err) {
-        if (err instanceof SecureStoreLockedError || err instanceof SecureStoreDecryptError) throw err;
-        log.warn(`buffer: skipping unreadable per-session buffer file ${name}: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-    return { entries, fileCount: names.length };
-  }
-  /**
-   * Read the legacy single-file buffer.json for migration. Null when absent,
-   * or unreadable while session files exist (they are authoritative; a
-   * corrupt leftover must not block startup). With no session files a corrupt
-   * legacy file THROWS, preserving the old contract so callers can reset it.
-   */
-  async readLegacy(hasSessionFiles) {
-    let raw;
-    try {
-      raw = await this.io.read(path13.join(this.stateDir, "buffer.json"));
-    } catch (err) {
-      if (err instanceof SecureStoreLockedError) throw err;
-      if (err instanceof Error && isMissing(asFsError(err))) return null;
-      throw err;
-    }
-    try {
-      const legacy = JSON.parse(raw);
-      return legacy;
-    } catch (err) {
-      if (!hasSessionFiles) throw err;
-      log.warn(
-        `buffer: legacy buffer.json is unreadable but per-session buffer files exist; ignoring the legacy file (${err instanceof Error ? err.message : String(err)})`
-      );
-      return null;
-    }
-  }
-  /**
-   * Load the whole buffer, migrating a legacy buffer.json once. A per-session
-   * file that parsed wins over the legacy snapshot (a crash mid-migration
-   * leaves exactly that pair); legacy entries without a usable file are
-   * written out, then the legacy file is retired. Both steps are idempotent.
-   */
-  async load() {
-    const { entries, fileCount } = await this.readAll();
-    const legacy = await this.readLegacy(fileCount > 0);
-    if (legacy !== null) {
-      for (const [key, entry] of legacyStateToEntries(legacy)) {
-        if (entries.has(key)) continue;
-        entries.set(key, entry);
-        await this.save(key, entry);
-      }
-      try {
-        await unlink4(path13.join(this.stateDir, "buffer.json"));
-      } catch (err) {
-        if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;
-      }
-    }
-    const out = /* @__PURE__ */ Object.create(null);
-    for (const [key, entry] of entries) out[key] = entry;
-    const def = entries.get("default");
-    return {
-      turns: def?.turns ?? [],
-      lastExtractionAt: def?.lastExtractionAt ?? null,
-      extractionCount: def?.extractionCount ?? 0,
-      entries: out
-    };
-  }
-  /**
-   * Reconcile the files with a WHOLE buffer state: write every entry, then
-   * delete files for keys no longer present. Writes first, deletes last: a
-   * crash leaves stale extra files (removed by the next reconcile) but never
-   * loses sessions the state says exist. Not on the observe hot path.
-   */
-  async reconcile(state) {
-    const entries = legacyStateToEntries(state);
-    const existing = await this.listFiles();
-    for (const [key, entry] of entries) await this.save(key, entry);
-    const live = new Set([...entries.keys()].map((key) => bufferSessionFileName(key)));
-    for (const name of existing) {
-      if (live.has(name)) continue;
-      try {
-        await unlink4(path13.join(this.dir, name));
-      } catch (err) {
-        if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;
-      }
-    }
-  }
-};
-
 // src/storage/supersession-audit.ts
-import { readdir as readdir6 } from "fs/promises";
-import path14 from "path";
+import { readdir as readdir5 } from "fs/promises";
+import path13 from "path";
 async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody, structuredAttributes) {
   let entries;
   try {
-    entries = await readdir6(lookup.correctionsDir, { withFileTypes: true });
+    entries = await readdir5(lookup.correctionsDir, { withFileTypes: true });
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return false;
     throw error;
@@ -5211,7 +4974,7 @@ async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody,
   for (const entry of entries) {
     if (isMacOsReplicationJunkBasename(entry.name)) continue;
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const memory = await lookup.readMemoryByPath(path14.join(lookup.correctionsDir, entry.name));
+    const memory = await lookup.readMemoryByPath(path13.join(lookup.correctionsDir, entry.name));
     if (memory?.frontmatter.category === "correction" && (memory.frontmatter.sourceMemoryId === oldMemoryId || memory.frontmatter.sourceMemoryId === void 0 && memory.frontmatter.lineage?.includes(oldMemoryId)) && memory.frontmatter.lineage?.includes(newMemoryId) && stripAttributesSuffix(memory.content) === auditBody && (structuredAttributes === void 0 || Object.entries(structuredAttributes).every(
       ([key, value]) => memory.frontmatter.structuredAttributes?.[key] === value
     ))) {
@@ -5303,19 +5066,19 @@ Reason: ${reason}`;
 // src/storage/dropped-extraction-chunk.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir } from "fs/promises";
-import path15 from "path";
+import path14 from "path";
 async function saveDroppedExtractionChunk(stateDir, writeSecureFile, bufferKey, reason, turns) {
-  const droppedDir = path15.join(stateDir, "dropped");
+  const droppedDir = path14.join(stateDir, "dropped");
   await mkdir(droppedDir, { recursive: true });
   const safeKey = bufferKey.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 80) || "default";
-  const filePath = path15.join(droppedDir, `${Date.now()}-${randomUUID2().slice(0, 8)}-${safeKey}.json`);
+  const filePath = path14.join(droppedDir, `${Date.now()}-${randomUUID2().slice(0, 8)}-${safeKey}.json`);
   const payload = { bufferKey, reason, droppedAt: (/* @__PURE__ */ new Date()).toISOString(), turns };
   await writeSecureFile(filePath, JSON.stringify(payload, null, 2));
   return filePath;
 }
 
 // src/storage/entity-timeline.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var ENTITY_TIMELINE_METADATA_MARKER = "remnic-meta-v1";
 function parseEntityTimelineBullet(bullet, fallbackTimestamp) {
   const trimmed = bullet.trim();
@@ -5757,7 +5520,7 @@ function fingerprintEntityStructuredFacts(entity) {
     (left, right) => left.key.localeCompare(right.key) || left.title.localeCompare(right.title) || left.facts.join("\n").localeCompare(right.facts.join("\n"))
   );
   if (normalizedSections.length === 0) return void 0;
-  return createHash5("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
 }
 function isEntitySynthesisStale(entity) {
   const structuredFactCount = countEntityStructuredFacts(entity);
@@ -6314,17 +6077,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path16.basename(pathRel, ".md").toLowerCase();
+  const basename = path15.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(path16.sep).join("/");
+  const normalizedPath = pathRel.split(path15.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path16.basename(pathRel, ".md");
+    const basename = path15.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -6797,9 +6560,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.entitySchemas = entitySchemas;
     this.deletionRevisionStore = new DeletionRevisionStore({
       baseDir,
-      deletionRevisionMetadataPath: path16.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
-      invalidationCommitMetadataPath: path16.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
-      deletionRevisionLockPath: path16.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
+      deletionRevisionMetadataPath: path15.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
+      invalidationCommitMetadataPath: path15.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
+      deletionRevisionLockPath: path15.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
       assertManagedStoragePath: (filePath, method) => this.assertManagedStoragePath(filePath, method)
     });
     this.casRevisions = new CasRevisionHost(baseDir);
@@ -6987,8 +6750,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path16.relative(this.stateDir, path16.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path16.isAbsolute(rel);
+    const rel = path15.relative(this.stateDir, path15.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path15.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -7103,8 +6866,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path16.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path16.sep}`) || rel.startsWith(`archive${path16.sep}`);
+    const rel = path15.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path15.sep}`) || rel.startsWith(`archive${path15.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -7191,7 +6954,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         void 0,
         this.baseDir
       );
-      const rel = path16.relative(this.baseDir, filePath).split(path16.sep).join("/");
+      const rel = path15.relative(this.baseDir, filePath).split(path15.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -7236,10 +6999,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     _StorageManager.okfConformanceByDir.set(memoryDir, enabled !== false);
   }
   okfConformanceEnabled() {
-    for (let dir = this.baseDir; ; dir = path16.dirname(dir)) {
+    for (let dir = this.baseDir; ; dir = path15.dirname(dir)) {
       const registered = _StorageManager.okfConformanceByDir.get(dir);
       if (registered !== void 0) return registered;
-      if (dir === path16.dirname(dir)) return true;
+      if (dir === path15.dirname(dir)) return true;
     }
   }
   /**
@@ -7283,12 +7046,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path16.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path15.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path16.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path15.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    return path16.join(this.stateDir, `.${kind}-version.log`);
+    return path15.join(this.stateDir, `.${kind}-version.log`);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -7395,7 +7158,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path16.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path15.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -7411,7 +7174,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    return path16.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path15.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -7437,10 +7200,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return this._fusionStore = new FusionArtifactStore(this.wearablesDir, this.baseDir, {
       writeFile: (p, c) => this.writeStorageSecureFile(p, c),
       readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
-      readDir: (d) => readdir7(d),
-      deleteFile: (p) => unlink5(p),
-      realpath: (p) => realpath3(p),
-      lstat: (p) => lstat5(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      readDir: (d) => readdir6(d),
+      deleteFile: (p) => unlink4(p),
+      realpath: (p) => realpath2(p),
+      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   _meetingRecordStore;
@@ -7455,10 +7218,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return this._meetingRecordStore = new MeetingRecordStore(this.baseDir, {
       writeFile: (p, c) => this.writeStorageSecureFile(p, c),
       readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
-      readDir: (d) => readdir7(d),
-      deleteFile: (p) => unlink5(p),
-      realpath: (p) => realpath3(p),
-      lstat: (p) => lstat5(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      readDir: (d) => readdir6(d),
+      deleteFile: (p) => unlink4(p),
+      realpath: (p) => realpath2(p),
+      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   /**
@@ -7525,25 +7288,25 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   get factsDir() {
-    return path16.join(this.baseDir, "facts");
+    return path15.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path16.join(this.baseDir, "corrections");
+    return path15.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path16.join(this.baseDir, "procedures");
+    return path15.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path16.join(this.baseDir, "reasoning-traces");
+    return path15.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path16.join(this.baseDir, "entities");
+    return path15.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path16.resolve(this.entitiesDir, `${name}.md`);
-    const relative2 = path16.relative(this.entitiesDir, filePath);
-    if (relative2 === "" || relative2.startsWith("..") || path16.isAbsolute(relative2)) {
+    const filePath = path15.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path15.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path15.isAbsolute(relative2)) {
       return null;
     }
     return filePath;
@@ -7554,7 +7317,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readDependencyPropagationQueueFile(filePath) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path16.relative(
+      path15.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.readDependencyPropagationQueueFile")
       )
@@ -7564,7 +7327,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async writeDependencyPropagationQueueFile(filePath, content) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path16.relative(
+      path15.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.writeDependencyPropagationQueueFile")
       )
@@ -7579,10 +7342,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path16.resolve(filePath);
-    const base = path16.resolve(this.baseDir);
-    const rel = path16.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path16.sep}`) || path16.isAbsolute(rel)) {
+    const resolved = path15.resolve(filePath);
+    const base = path15.resolve(this.baseDir);
+    const rel = path15.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path15.sep}`) || path15.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -7619,7 +7382,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path16.relative(this.baseDir, target).split(path16.sep).join("/");
+    const relPath = path15.relative(this.baseDir, target).split(path15.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) {
@@ -7633,11 +7396,11 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     if (encrypted) {
       const content = await readMaybeEncryptedFileBuffer(target, this._secureStoreKey, this.baseDir);
       digest = {
-        sha256: createHash6("sha256").update(content).digest("hex"),
+        sha256: createHash5("sha256").update(content).digest("hex"),
         bytes: content.byteLength
       };
     } else {
-      const hash = createHash6("sha256");
+      const hash = createHash5("sha256");
       let bytes = 0;
       for await (const rawChunk of createReadStream(target)) {
         const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
@@ -7704,7 +7467,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       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(path16.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir2(path15.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile2(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -7805,7 +7568,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir2(path16.dirname(filePath), { recursive: true });
+    await mkdir2(path15.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -7831,13 +7594,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path16.join(this.baseDir, "state");
+    return path15.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path16.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path15.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path16.join(this.stateDir, "entity-synthesis-queue.json");
+    return path15.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -7847,7 +7610,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path16.join(this.stateDir, "tombstones.jsonl");
+    return path15.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -8160,55 +7923,55 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return legacyMatches.length > 0 ? [...new Set(legacyMatches.map((content) => ContentHashIndex.computeHash(content)))] : [persistedHash];
   }
   get questionsDir() {
-    return path16.join(this.baseDir, "questions");
+    return path15.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path16.join(this.baseDir, "artifacts");
+    return path15.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path16.join(this.baseDir, "identity");
+    return path15.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path16.join(this.identityDir, "identity-anchor.md");
+    return path15.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path16.join(this.identityDir, "incidents");
+    return path15.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path16.join(this.identityDir, "audits", "weekly");
+    return path15.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path16.join(this.identityDir, "audits", "monthly");
+    return path15.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path16.join(this.identityDir, "improvement-loops.md");
+    return path15.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path16.join(this.identityDir, "reflections.md");
+    return path15.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path16.join(this.baseDir, "profile.md");
+    return path15.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path16.join(this.stateDir, "memory-actions.jsonl");
+    return path15.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path16.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path15.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path16.join(this.stateDir, "compression-guidelines.md");
+    return path15.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path16.join(this.stateDir, "compression-guidelines.draft.md");
+    return path15.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path16.join(this.stateDir, "compression-guideline-state.json");
+    return path15.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path16.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path15.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path16.join(this.stateDir, "behavior-signals.jsonl");
+    return path15.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -8240,7 +8003,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path16.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path15.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -8303,7 +8066,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path16.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path15.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     const raw = readEntityAliasConfigSync(this.baseDir);
     if (raw === void 0) return;
@@ -8341,9 +8104,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     await mkdir2(this.baseDir, { recursive: true });
     await validateRoots(this.baseDir, this.entitiesDir, this.stateDir, this.archiveDir);
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir2(path16.join(this.factsDir, today), { recursive: true });
-    await mkdir2(path16.join(this.proceduresDir, today), { recursive: true });
-    await mkdir2(path16.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir2(path15.join(this.factsDir, today), { recursive: true });
+    await mkdir2(path15.join(this.proceduresDir, today), { recursive: true });
+    await mkdir2(path15.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir2(this.correctionsDir, { recursive: true });
     await mkdir2(this.entitiesDir, { recursive: true });
     await mkdir2(this.stateDir, { recursive: true });
@@ -8353,7 +8116,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     await mkdir2(this.identityIncidentsDir, { recursive: true });
     await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir2(path16.join(this.baseDir, "config"), { recursive: true });
+    await mkdir2(path15.join(this.baseDir, "config"), { recursive: true });
     await this.entityCanonicalIdMigration.begin(options.waitForEntityMigration !== false, this.entitiesDir);
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
@@ -8376,11 +8139,11 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir2(this.correctionsDir, { recursive: true });
-      return path16.join(this.correctionsDir, `${id}.md`);
+      return path15.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path16.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path15.join(getCategoryDir(this.baseDir, category), today);
     await mkdir2(datedDir, { recursive: true });
-    return path16.join(datedDir, `${id}.md`);
+    return path15.join(datedDir, `${id}.md`);
   }
   async findExistingTombstoneBlockedMemory(content, category, sourceConnector) {
     const identity = buildExplicitCaptureDedupKey(content, category, sourceConnector);
@@ -8551,7 +8314,7 @@ ${sanitized.text}
             }
           });
         } catch (err) {
-          await unlink5(filePath).catch(() => void 0);
+          await unlink4(filePath).catch(() => void 0);
           this.invalidateAllMemoriesCache();
           await this.rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath);
           throw err;
@@ -8759,7 +8522,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path16.join(this.artifactsDir, day);
+    const dir = path15.join(this.artifactsDir, day);
     await mkdir2(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -8786,7 +8549,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path16.join(dir, `${id}.md`);
+    const filePath = path15.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
@@ -9080,7 +8843,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path16.join(this.baseDir, "cold");
+    const coldRoot = path15.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -9198,7 +8961,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path16.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path15.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -9262,10 +9025,10 @@ ${sanitized.text}
     const root = this.archiveDir;
     const readDir = async (dir) => {
       try {
-        const entries = (await readdir7(dir, { withFileTypes: true })).filter((e) => !isMacOsReplicationJunkBasename(e.name));
+        const entries = (await readdir6(dir, { withFileTypes: true })).filter((e) => !isMacOsReplicationJunkBasename(e.name));
         for (const entry of entries) {
           checkCorpusReadAbort(options);
-          const fullPath = path16.join(dir, entry.name);
+          const fullPath = path15.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -9305,7 +9068,7 @@ ${sanitized.text}
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path16.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path15.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -9320,13 +9083,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path16.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path15.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path16.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path15.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path16.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path15.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     assertNotOkfReservedBasename(targetPath);
@@ -9358,7 +9121,7 @@ ${memory.content}
         });
       } catch (err) {
         if (priorDest === null) {
-          await unlink5(targetPath).catch(() => void 0);
+          await unlink4(targetPath).catch(() => void 0);
         } else {
           await writeFile2(targetPath, priorDest).catch(() => void 0);
         }
@@ -9405,8 +9168,8 @@ ${memory.content}
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
             durable = true;
-            const sourcePath = path16.resolve(current.path);
-            const destPath = path16.resolve(targetPath);
+            const sourcePath = path15.resolve(current.path);
+            const destPath = path15.resolve(targetPath);
             if (sourcePath !== destPath) {
               await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
@@ -9430,8 +9193,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path16.resolve(memory.path);
-    const destPath = path16.resolve(targetPath);
+    const sourcePath = path15.resolve(memory.path);
+    const destPath = path15.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -9441,7 +9204,7 @@ ${memory.content}
     return { changed, targetPath };
   }
   get archiveDir() {
-    return path16.join(this.baseDir, "archive");
+    return path15.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -9454,7 +9217,7 @@ ${memory.content}
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
         const today = now.toISOString().slice(0, 10);
-        const destDir = path16.join(this.archiveDir, today);
+        const destDir = path15.join(this.archiveDir, today);
         await mkdir2(destDir, { recursive: true });
         const refIdsAtWrite = this.currentHistoricalIds();
         const updatedFm = canonicalizeEntityRefOption(
@@ -9470,7 +9233,7 @@ ${memory.content}
 
 ${current.content}
 `;
-        const destPath = path16.join(destDir, path16.basename(current.path));
+        const destPath = path15.join(destDir, path15.basename(current.path));
         const priorDest = await this.readStorageSecureFile(destPath).catch(() => null);
         await recordArchiveWrite(this.baseDir, destPath, () => this.writeStorageSecureFile(destPath, fileContent));
         if (typeof current.frontmatter.entityRef === "string") {
@@ -9484,22 +9247,12 @@ ${current.content}
             );
           } catch (err) {
             if (priorDest === null) {
-              await recordArchiveDelete2(
-                this.baseDir,
-                destPath,
-                () => unlink5(destPath).then(
-                  () => true,
-                  () => false
-                )
-              );
+              await recordArchiveDelete2(this.baseDir, destPath, () => unlink4(destPath).then(() => true, () => false));
             } else {
               await recordArchiveDelete2(
                 this.baseDir,
                 destPath,
-                () => this.writeStorageSecureFile(destPath, priorDest).then(
-                  () => true,
-                  () => false
-                )
+                () => this.writeStorageSecureFile(destPath, priorDest).then(() => true, () => false)
               );
             }
             throw err;
@@ -9704,7 +9457,7 @@ ${memory.content}
 `;
     await this.writeTombstoneBlockedFrontmatter(memory, fileContent, updated, async () => {
       this.invalidateAllMemoriesCache();
-      if (memory.path.includes(`${path16.sep}cold${path16.sep}`)) {
+      if (memory.path.includes(`${path15.sep}cold${path15.sep}`)) {
         this.invalidateColdMemoriesCache();
       }
     });
@@ -9716,7 +9469,7 @@ ${memory.content}
     }
     if (mentionReentry && !entityMentionEpoch.neutral(memory.frontmatter, updated)) entityMentionEpoch.bump(this.baseDir);
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path16.sep}cold${path16.sep}`)) {
+    if (memory.path.includes(`${path15.sep}cold${path15.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -9809,16 +9562,24 @@ ${memory.content}
     await this.bufferSessionFiles().reconcile(state);
   }
   async saveBufferSession(key, entry) {
-    await this.bufferSessionFiles().save(key, entry);
+    return await this.bufferSessionFiles().save(key, entry);
   }
   async deleteBufferSession(key) {
     await this.bufferSessionFiles().remove(key);
   }
+  /** Sync gate check for the extraction queue: is this session claimed by a buffer drain? */
+  isBufferSessionClaimed(key) {
+    return this.bufferSessionFiles().isClaimed(key);
+  }
+  /** The drain-claim store for this memory root (CLI drain + worker). */
+  bufferDrainClaims() {
+    return this.bufferSessionFiles().claims;
+  }
   saveDroppedExtractionChunk(bufferKey, reason, turns) {
     return saveDroppedExtractionChunk(this.stateDir, (file, content) => this.writeStorageSecureFile(file, content), bufferKey, reason, turns);
   }
   async loadMeta() {
-    const metaPath = path16.join(this.stateDir, "meta.json");
+    const metaPath = path15.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -9851,7 +9612,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    await this.writeStorageSecureFile(path16.join(this.stateDir, "meta.json"), JSON.stringify(state, null, 2));
+    await this.writeStorageSecureFile(path15.join(this.stateDir, "meta.json"), JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
     if (events.length === 0) return 0;
@@ -9920,7 +9681,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir2(path16.dirname(target), { recursive: true });
+        await mkdir2(path15.dirname(target), { recursive: true });
       }
     );
   }
@@ -10018,7 +9779,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path16.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path15.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -10031,7 +9792,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path16.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path15.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -10187,7 +9948,7 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash6("sha256").update(draftContent).digest("hex");
+      const contentHash = createHash5("sha256").update(draftContent).digest("hex");
       if (contentHash !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
@@ -10196,8 +9957,8 @@ ${memory.content}
       activationState: "active"
     });
     await Promise.all([
-      unlink5(this.compressionGuidelineDraftPath).catch(() => void 0),
-      unlink5(this.compressionGuidelineDraftStatePath).catch(() => void 0)
+      unlink4(this.compressionGuidelineDraftPath).catch(() => void 0),
+      unlink4(this.compressionGuidelineDraftStatePath).catch(() => void 0)
     ]);
     return true;
   }
@@ -10266,7 +10027,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path16.join(this.questionsDir, `${id}.md`);
+    const filePath = path15.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -10325,11 +10086,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path16.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path15.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path16.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path15.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -10589,7 +10350,7 @@ ${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) => [path16.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path15.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     let entityRefMoved = false;
@@ -10597,7 +10358,7 @@ ${reflection}
     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(path16.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path15.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       try {
         const applied = await this.withTombstoneBlockedMemoryPathLock(memory.path, async (current) => {
@@ -10629,7 +10390,7 @@ ${current.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...applied.current, frontmatter: applied.newFm }, keyId);
         }
-        appliedPatches.set(path16.resolve(memory.path), {
+        appliedPatches.set(path15.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -10647,7 +10408,7 @@ ${current.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path16.resolve(m.path));
+            const patch = appliedPatches.get(path15.resolve(m.path));
             return patch ? {
               ...m,
               frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed }
@@ -10677,7 +10438,7 @@ ${current.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path16.basename(filePath, ".md");
+      const memoryId = path15.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -10689,7 +10450,7 @@ ${current.content}
       const preferredMatches = [];
       for (const preferredPath of preferred) {
         const directCandidates = new Set(qmdResultPathCandidates(this.baseDir, preferredPath));
-        const directMatch = existingPaths.find((filePath) => directCandidates.has(path16.resolve(filePath)));
+        const directMatch = existingPaths.find((filePath) => directCandidates.has(path15.resolve(filePath)));
         if (directMatch) {
           preferredMatches.push(directMatch);
           continue;
@@ -10701,7 +10462,7 @@ ${current.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path16.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path15.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -10892,7 +10653,7 @@ ${sanitized.text}
     }
     if (!oldMemory) return false;
     const requireActiveAtWrite = options.requireActive === true || inferMemoryStatus(oldMemory.frontmatter, toMemoryPathRel(this.baseDir, oldMemory.path)) === "active";
-    const operationId = createHash6("sha256").update(
+    const operationId = createHash5("sha256").update(
       JSON.stringify({
         oldMemoryId,
         newMemoryId,
@@ -11023,21 +10784,21 @@ ${current.content}
     }
   }
   get summariesDir() {
-    return path16.join(this.baseDir, "summaries");
+    return path15.join(this.baseDir, "summaries");
   }
   async writeSummary(summary) {
     await mkdir2(this.summariesDir, { recursive: true });
-    const filePath = path16.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path15.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
   async readSummaries() {
     try {
-      const files = await readdir7(this.summariesDir);
+      const files = await readdir6(this.summariesDir);
       const summaries = [];
       for (const file of files) {
         if (isMacOsReplicationJunkBasename(file) || !file.endsWith(".json")) continue;
-        const filePath = path16.join(this.summariesDir, file);
+        const filePath = path15.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -11107,13 +10868,13 @@ ${current.content}
     return archived;
   }
   async saveTopics(topics) {
-    const metaPath = path16.join(this.stateDir, "topics.json");
+    const metaPath = path15.join(this.stateDir, "topics.json");
     await mkdir2(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`);
   }
   async loadTopics() {
-    const metaPath = path16.join(this.stateDir, "topics.json");
+    const metaPath = path15.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -11233,4 +10994,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-WXBVGKS6.js.map
+//# sourceMappingURL=chunk-N7RAABFM.js.map