@remnic/core 9.69.45 → 9.69.46

package/dist/{chunk-IAT5WFEU.js → chunk-QUFJ3NJE.js}

@@ -1,9 +1,3 @@
-import {
-  TombstoneStore,
-  applyTombstoneResurrectionGate,
-  buildRetiredFactTombstoneInputs,
-  collectRetiredMemoriesForRebuild
-} from "./chunk-46WM6JX2.js";
 import {
   WEARABLES_DIR_NAME,
   escapeSegmentText,
@@ -15,9 +9,15 @@ import {
   unescapeSegmentText,
   unescapeSpeakerLabel
 } from "./chunk-UHVXE24Y.js";
+import {
+  TombstoneStore,
+  applyTombstoneResurrectionGate,
+  buildRetiredFactTombstoneInputs,
+  collectRetiredMemoriesForRebuild
+} from "./chunk-46WM6JX2.js";
 import {
   normalizeQmdResultPath
-} from "./chunk-T3F2HWIG.js";
+} from "./chunk-TZ44E732.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -31,6 +31,9 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
 } from "./chunk-66YUOI53.js";
+import {
+  createMemorySnapshot
+} from "./chunk-S2HLHAZ4.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -39,9 +42,6 @@ import {
   rewriteProjectedEntityReferences,
   rewriteProjectedMemoryEntityReference
 } from "./chunk-MRPOZBJC.js";
-import {
-  createMemorySnapshot
-} from "./chunk-S2HLHAZ4.js";
 import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
@@ -59,18 +59,17 @@ import {
   serializeFaithfulnessFields
 } from "./chunk-J3IWHCMF.js";
 import {
+  CasRevisionHost,
   DeletionRevisionStore,
   TombstoneBlockedCaptureIndexHost,
   buildCapturePathLockIdentity,
   buildExplicitCaptureDedupKey,
   invalidationCommitFingerprint,
   isQueuedReviewMemory,
-  isValidManagedStoragePath,
-  nextCasRevisionIso,
   parseTombstoneBlockedOfflineSyncMemory,
   tombstoneBlocked,
   withCasCommitReceipt
-} from "./chunk-SHEHQBCG.js";
+} from "./chunk-DUJYRVUD.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -261,17 +260,17 @@ import {
 import {
   lstat as lstat3,
   readdir as readdir6,
-  readFile as readFile3,
+  readFile as readFile2,
   realpath as realpath3,
   stat as stat3,
   writeFile as writeFile2,
-  mkdir as mkdir2,
-  unlink as unlink5,
+  mkdir,
+  unlink as unlink4,
   appendFile,
-  open as open2
+  open
 } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, statSync as statSync2 } from "fs";
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 
 // src/preferences/drift-types.ts
 function serializeDriftProvenance(fm) {
@@ -295,7 +294,7 @@ function parseDriftProvenance(fm) {
 }
 
 // src/storage.ts
-import path14 from "path";
+import path13 from "path";
 
 // src/storage/tombstone-migration-sources.ts
 import { statSync } from "fs";
@@ -2349,543 +2348,9 @@ ${rows.join("\n")}
   }
 };
 
-// src/storage/cas-revision-store.ts
-import { createHash, randomUUID } from "crypto";
-import { mkdir, open, readFile, rename, unlink as unlink2 } from "fs/promises";
-import path6 from "path";
-var ACCESS_TELEMETRY_FRONTMATTER_KEY = /^(?:accessCount|lastAccessed):/;
-function canonicalSemanticFileText(raw) {
-  const lines = raw.split("\n");
-  if (lines[0] !== "---") return raw;
-  const closing = lines.indexOf("---", 1);
-  if (closing === -1) return raw;
-  const frontmatter = lines.slice(1, closing).filter((line) => !ACCESS_TELEMETRY_FRONTMATTER_KEY.test(line));
-  return [...lines.slice(0, 1), ...frontmatter, ...lines.slice(closing)].join("\n");
-}
-var CAS_REVISION_LOCK_STALE_MS = 6e4;
-var CAS_REVISION_LOCK_MAX_WAIT_MS = 12e4;
-var SHA256_HEX = /^[0-9a-f]{64}$/;
-function isDigestOrNullOrUndefined(value) {
-  if (value === void 0 || value === null) return true;
-  return typeof value === "string" && SHA256_HEX.test(value);
-}
-function pendingWriteHasLanded(view) {
-  if (view.writeLanded === true) return true;
-  if (view.writeLanded === false) return false;
-  return view.expectedDigest !== void 0;
-}
-var CasRevisionStore = class {
-  baseDir;
-  legacyMetadataPath;
-  constructor(baseDir) {
-    this.baseDir = baseDir;
-    this.legacyMetadataPath = path6.join(baseDir, ".offline-sync", "cas-revisions.v1.json");
-  }
-  parseCasRevisionMetadata(raw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new Error("CAS revision metadata is invalid.");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("CAS revision metadata is invalid.");
-    }
-    const root = parsed;
-    if (Object.keys(root).sort().join(",") !== "revisions,version" || root.version !== 1 || !Array.isArray(root.revisions)) {
-      throw new Error("CAS revision metadata is invalid.");
-    }
-    const revisions = /* @__PURE__ */ new Map();
-    for (const rawEntry of root.revisions) {
-      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-        throw new Error("CAS revision metadata is invalid.");
-      }
-      const entry = rawEntry;
-      if (Object.keys(entry).sort().join(",") !== "path,revision" || typeof entry.path !== "string" || !isValidManagedStoragePath(entry.path) || typeof entry.revision !== "string" || entry.revision.length === 0 || revisions.has(entry.path)) {
-        throw new Error("CAS revision metadata is invalid.");
-      }
-      revisions.set(entry.path, entry.revision);
-    }
-    return revisions;
-  }
-  async readLegacyMetadata() {
-    const baseDir = path6.resolve(this.baseDir);
-    const legacyPath = await resolveSafeStoragePath(baseDir, path6.relative(baseDir, this.legacyMetadataPath));
-    let raw;
-    try {
-      raw = await readFile(legacyPath, "utf8");
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
-      throw new Error("CAS revision metadata is unavailable.");
-    }
-    return this.parseCasRevisionMetadata(raw);
-  }
-  /** #2813 (P1 A): every sidecar path is resolved (and symlink-audited)
-   * inside the memory root before it is used for a lock, read, rename, or
-   * unlink. A symlinked `.offline-sync`, `.offline-sync/cas-revisions`, or
-   * shard file makes this throw, so no sidecar traffic can follow a link
-   * out of the root. */
-  async getSafeShardInfo(relativePath) {
-    const baseDir = path6.resolve(this.baseDir);
-    const hash = createHash("sha256").update(relativePath).digest("hex");
-    const shardPath = await resolveSafeStoragePath(baseDir, ".offline-sync", "cas-revisions", `${hash}.json`);
-    const lockPath2 = await resolveSafeStoragePath(baseDir, ".offline-sync", "cas-revisions", `${hash}.json.lock`);
-    return { shardPath, lockPath: lockPath2 };
-  }
-  async readShardView(shardPath, relativePath) {
-    let raw;
-    try {
-      raw = await readFile(shardPath, "utf8");
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return { kind: "missing" };
-      throw error;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new Error("CAS revision shard is unreadable.");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { kind: "foreign" };
-    }
-    const root = parsed;
-    if (root.state !== void 0) {
-      if (root.version !== 1 || typeof root.path !== "string" || typeof root.revision !== "string" || root.revision.length === 0 || root.state !== "pending" && root.state !== "committed" || root.previous !== void 0 && (typeof root.previous !== "string" || root.previous.length === 0) || !isDigestOrNullOrUndefined(root.baselineDigest) || !isDigestOrNullOrUndefined(root.expectedDigest) || root.writeLanded !== void 0 && typeof root.writeLanded !== "boolean") {
-        throw new Error("CAS revision shard is unreadable.");
-      }
-      const foreign = root.path !== relativePath;
-      const committedDigest = typeof root.committedDigest === "string" ? root.committedDigest : void 0;
-      const committedSemanticFingerprint = typeof root.committedSemanticFingerprint === "string" ? root.committedSemanticFingerprint : void 0;
-      return root.state === "pending" ? {
-        kind: "pending",
-        revision: root.revision,
-        previous: root.previous,
-        foreign,
-        baselineDigest: root.baselineDigest,
-        expectedDigest: root.expectedDigest,
-        ...typeof root.writeLanded === "boolean" ? { writeLanded: root.writeLanded } : {}
-      } : {
-        kind: "committed",
-        revision: root.revision,
-        committedDigest,
-        committedSemanticFingerprint,
-        foreign
-      };
-    }
-    if (root.version === 1 && root.path === relativePath && typeof root.revision === "string" && root.revision.length > 0) {
-      const committedDigest = typeof root.committedDigest === "string" ? root.committedDigest : void 0;
-      const committedSemanticFingerprint = typeof root.committedSemanticFingerprint === "string" ? root.committedSemanticFingerprint : void 0;
-      return {
-        kind: "committed",
-        revision: root.revision,
-        committedDigest,
-        committedSemanticFingerprint,
-        foreign: false
-      };
-    }
-    return { kind: "foreign" };
-  }
-  async readStandingRevision(relativePath) {
-    try {
-      return await this.readStandingRevisionStrict(relativePath);
-    } catch (error) {
-      log.warn(`CasRevisionStore failed to read standing revision for ${relativePath}: ${error}`);
-      return void 0;
-    }
-  }
-  /** #2813 (P1 A): strict core of {@link readStandingRevision}. Returns
-   * undefined ONLY when no receipt exists for the target — the shard is
-   * absent (or names another target) and the legacy metadata holds no
-   * entry. THROWS when the standing receipt cannot be determined: an
-   * unreadable or corrupt shard, a PENDING reservation awaiting
-   * finalization or recovery, or unreadable or invalid legacy metadata.
-   * Fail-open callers collapse the throw into undefined; truthful callers
-   * ({@link readRevisionStatus}) report `unavailable` so a transaction can
-   * refuse instead of mistaking the failure for absence. */
-  async readStandingRevisionStrict(relativePath) {
-    const { shardPath } = await this.getSafeShardInfo(relativePath);
-    const view = await this.readShardView(shardPath, relativePath);
-    if (view.kind === "pending") {
-      throw new Error(
-        `CAS revision receipt for ${relativePath} is pending finalization (recovery needed).`
-      );
-    }
-    if (view.kind === "committed" && !view.foreign) {
-      return {
-        revision: view.revision,
-        committedDigest: view.committedDigest,
-        committedSemanticFingerprint: view.committedSemanticFingerprint
-      };
-    }
-    const legacyMap = await this.readLegacyMetadata();
-    const legacyRev = legacyMap.get(relativePath);
-    return legacyRev === void 0 ? void 0 : { revision: legacyRev };
-  }
-  async writeShard(shardPath, relativePath, revision, lock, state, previous, evidence) {
-    let payload;
-    if (state === "committed") {
-      payload = { version: 1, path: relativePath, revision, state };
-      if (evidence?.committedDigest !== void 0) {
-        payload.committedDigest = evidence.committedDigest;
-      }
-      if (evidence?.committedSemanticFingerprint !== void 0) {
-        payload.committedSemanticFingerprint = evidence.committedSemanticFingerprint;
-      }
-    } else {
-      payload = { version: 1, path: relativePath, revision, state };
-      if (previous !== void 0) payload.previous = previous;
-      if (evidence !== void 0) {
-        if (evidence.baselineDigest !== void 0) payload.baselineDigest = evidence.baselineDigest;
-        if (evidence.expectedDigest !== void 0) payload.expectedDigest = evidence.expectedDigest;
-        if (evidence.writeLanded !== void 0) payload.writeLanded = evidence.writeLanded;
-      }
-    }
-    const baseDir = path6.resolve(this.baseDir);
-    const temporaryPath = await resolveSafeStoragePath(
-      baseDir,
-      path6.relative(baseDir, `${shardPath}.${process.pid}.${randomUUID()}.tmp`)
-    );
-    let handle = null;
-    try {
-      await mkdir(path6.dirname(shardPath), { recursive: true });
-      handle = await open(temporaryPath, "wx", 384);
-      await handle.writeFile(`${JSON.stringify(payload)}
-`, "utf8");
-      await handle.sync();
-      await handle.close();
-      handle = null;
-      if (!await lock.refresh()) {
-        throw new Error("CAS revision shard lock was lost.");
-      }
-      await rename(temporaryPath, shardPath);
-    } finally {
-      if (handle !== null) {
-        await handle.close().catch((error) => {
-          log.warn("failed to close CAS revision shard temporary file", error);
-        });
-      }
-      await unlink2(temporaryPath).catch((error) => {
-        if (!isErrnoCode(error, "ENOENT")) {
-          log.warn("failed to clean up CAS revision shard temporary file", error);
-        }
-      });
-    }
-  }
-  async resolveRelativePath(filePath) {
-    const baseDir = path6.resolve(this.baseDir);
-    const target = await resolveSafeStoragePath(baseDir, path6.relative(baseDir, path6.resolve(baseDir, filePath)));
-    return path6.relative(baseDir, target).split(path6.sep).join("/");
-  }
-  async withShardLock(relativePath, task) {
-    const { lockPath: lockPath2 } = await this.getSafeShardInfo(relativePath);
-    return await withHeldFileLock(
-      lockPath2,
-      { staleMs: CAS_REVISION_LOCK_STALE_MS, maxWaitMs: CAS_REVISION_LOCK_MAX_WAIT_MS },
-      async (acquired, lock) => {
-        if (!acquired) throw new Error("CAS revision lock is unavailable.");
-        return await task(lock);
-      }
-    );
-  }
-  /** The target's standing revision token, or undefined when no receipt was
-   * ever minted for it. Fail-open on storage/read errors. */
-  async readRevision(filePath) {
-    try {
-      const relativePath = await this.resolveRelativePath(filePath);
-      return (await this.readStandingRevision(relativePath))?.revision;
-    } catch (error) {
-      log.warn(`CasRevisionStore.readRevision failed for ${filePath}: ${error}`);
-      return void 0;
-    }
-  }
-  /** #2813 (P1 A): the truthful standing-receipt read. `absent` means no
-   * receipt was ever minted for the target — undefined semantics stay
-   * correct for those records. `unavailable` means the sidecar could not
-   * be read OR a reservation is pending finalization; callers that
-   * transact on receipt identity MUST refuse rather than treat the
-   * failure as absence. */
-  async readRevisionStatus(filePath) {
-    try {
-      const relativePath = await this.resolveRelativePath(filePath);
-      const standing = await this.readStandingRevisionStrict(relativePath);
-      return standing === void 0 ? { status: "absent" } : {
-        status: "present",
-        revision: standing.revision,
-        ...standing.committedDigest !== void 0 ? { committedDigest: standing.committedDigest } : {},
-        ...standing.committedSemanticFingerprint !== void 0 ? { committedSemanticFingerprint: standing.committedSemanticFingerprint } : {}
-      };
-    } catch (error) {
-      return { status: "unavailable", reason: error instanceof Error ? error.message : String(error) };
-    }
-  }
-  /** #2813 (P1 C): reserve the NEXT revision token as a durable PENDING
-   * marker under the target's shard lock — the write-ahead record of a
-   * receipt transaction. The token is strictly greater than the standing
-   * token (max(clock, prev + 1ms)), so two commits can never share a
-   * receipt — not within one millisecond, not across a backward clock
-   * step. Refuses while another reservation is pending (recovery needed)
-   * or the standing receipt cannot be determined. The caller MUST either
-   * `commit` after its durable write lands or `abort` when it fails.
-   * #2807: the marker records the reserve-time fingerprint (`baselineDigest`)
-   * and optional expected post-write fingerprint (`expectedDigest`) with
-   * `writeLanded: false`. {@link recoverPendingRevision} decides crashes
-   * before or after the memory write from that evidence. */
-  async beginRevisionTransaction(filePath, expectedContent) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    return await this.withShardLock(relativePath, async (lock) => {
-      const standingInfo = await this.readStandingRevisionStrict(relativePath);
-      const standing = standingInfo?.revision;
-      const next = nextCasRevisionIso(standing);
-      const baselineDigest = await this.digestDurableFile(relativePath);
-      const expectedDigest = expectedContent != null ? this.digestContent(expectedContent) : void 0;
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      await this.writeShard(shardPath, relativePath, next, lock, "pending", standing, {
-        baselineDigest,
-        ...expectedDigest !== void 0 ? { expectedDigest } : {},
-        writeLanded: false
-      });
-      return {
-        pendingRevision: next,
-        writeLanded: () => this.recordPendingWriteLanded(relativePath, next),
-        commit: () => this.finalizeRevisionTransaction(relativePath, next, "commit"),
-        abort: () => this.finalizeRevisionTransaction(relativePath, next, "abort")
-      };
-    });
-  }
-  digestContent(content) {
-    const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : content;
-    return createHash("sha256").update(bytes).digest("hex");
-  }
-  async digestDurableFile(filePath) {
-    const bytes = await this.readDurableBytes(filePath);
-    return bytes === null ? null : createHash("sha256").update(bytes).digest("hex");
-  }
-  /** #2870: canonical SEMANTIC fingerprint of the durable file — its text
-   * with the access-telemetry frontmatter keys stripped
-   * ({@link canonicalSemanticFileText}), hashed. Null means the file was
-   * absent. A fingerprint, never memory content. */
-  async semanticFingerprintDurableFile(filePath) {
-    const bytes = await this.readDurableBytes(filePath);
-    return bytes === null ? null : createHash("sha256").update(canonicalSemanticFileText(bytes.toString("utf8"))).digest("hex");
-  }
-  async readDurableBytes(filePath) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    const baseDir = path6.resolve(this.baseDir);
-    const target = await resolveSafeStoragePath(baseDir, relativePath);
-    try {
-      return await readFile(target);
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return null;
-      throw new Error(
-        `CAS revision evidence: durable memory file ${relativePath} is unreadable: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  /** #2807: mark the reserved write as landed. Verifies a pre-recorded
-   * expected digest against the durable file, or records the file digest
-   * when none was reserved. Sets `writeLanded: true`. Idempotent. */
-  async recordPendingWriteLanded(relativePath, token) {
-    await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind !== "pending" || view.foreign || view.revision !== token) {
-        throw new Error(
-          `CAS revision evidence recording refused for ${relativePath}: the pending marker does not match the reserved token.`
-        );
-      }
-      if (pendingWriteHasLanded(view) && view.writeLanded !== false) return;
-      const currentDigest = await this.digestDurableFile(relativePath);
-      if (view.expectedDigest !== void 0 && currentDigest !== view.expectedDigest) {
-        throw new Error(
-          `CAS revision evidence recording refused for ${relativePath}: the durable file does not match the reserved expected digest.`
-        );
-      }
-      await this.writeShard(shardPath, relativePath, token, lock, "pending", view.previous, {
-        baselineDigest: view.baselineDigest === void 0 ? null : view.baselineDigest,
-        expectedDigest: view.expectedDigest !== void 0 ? view.expectedDigest : currentDigest,
-        writeLanded: true
-      });
-    });
-  }
-  async finalizeRevisionTransaction(relativePath, token, outcome) {
-    await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind === "pending" && !view.foreign && view.revision === token) {
-        if (outcome === "commit") {
-          const committedDigest = view.expectedDigest ?? await this.digestDurableFile(relativePath);
-          const committedSemanticFingerprint = await this.semanticFingerprintDurableFile(relativePath);
-          await this.writeShard(shardPath, relativePath, token, lock, "committed", void 0, {
-            committedDigest,
-            committedSemanticFingerprint
-          });
-        } else if (view.previous !== void 0) {
-          await this.writeShard(shardPath, relativePath, view.previous, lock, "committed");
-        } else {
-          await unlink2(shardPath);
-        }
-        return;
-      }
-      if (outcome === "commit" && view.kind === "committed" && !view.foreign && view.revision === token) {
-        return;
-      }
-      if (outcome === "abort" && view.kind === "missing") {
-        return;
-      }
-      throw new Error(
-        `CAS revision transaction ${outcome} refused for ${relativePath}: the pending marker does not match the reserved token.`
-      );
-    });
-  }
-  /** #2813 (P1 C): recovery for a reservation left PENDING by a crash or a
-   * failed publication. The caller supplies the KNOWN outcome of the
-   * durable memory write: `fileWriteLanded` publishes the pending token as
-   * the COMMITTED receipt; otherwise the reservation is discarded and the
-   * previous standing token restored. Idempotent — an already-committed or
-   * absent shard is reported, not mutated. */
-  async reconcilePendingRevision(filePath, fileWriteLanded) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    return await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind === "committed") return "committed";
-      if (view.kind !== "pending") return "absent";
-      if (view.foreign) {
-        throw new Error(
-          `CAS revision pending marker for ${relativePath} names another target; manual recovery is required.`
-        );
-      }
-      if (fileWriteLanded) {
-        const committedDigest = view.expectedDigest ?? await this.digestDurableFile(relativePath);
-        const committedSemanticFingerprint = await this.semanticFingerprintDurableFile(relativePath);
-        await this.writeShard(shardPath, relativePath, view.revision, lock, "committed", void 0, {
-          committedDigest,
-          committedSemanticFingerprint
-        });
-      } else if (view.previous !== void 0) {
-        await this.writeShard(shardPath, relativePath, view.previous, lock, "committed");
-      } else {
-        await unlink2(shardPath);
-      }
-      return "reconciled";
-    });
-  }
-  /** #2807 (P1): evidence-based recovery for a reservation left PENDING by
-   * a crash between reserve and finalize. Under the shard lock, the durable
-   * file's current fingerprint is compared against the marker:
-   * - matches `expectedDigest` → publish the pending token as COMMITTED;
-   * - matches `baselineDigest` (including both absent) → abort and restore;
-   * - anything else THROWS. Recovery never guesses.
-   *
-   * `onlyWithWriteEvidence` is the unlocked read path. A marker whose write
-   * has not landed (`writeLanded` false, or legacy with no expectedDigest)
-   * may belong to a live writer, so it returns `reserved`. A landed marker
-   * whose file no longer matches `expectedDigest` throws ambiguity. */
-  async recoverPendingRevision(filePath, options) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    return await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind === "missing" || view.kind === "foreign") return "absent";
-      if (view.kind === "committed") return view.foreign ? "absent" : "committed";
-      if (view.foreign) {
-        throw new Error(
-          `CAS revision pending marker for ${relativePath} names another target; manual recovery is required.`
-        );
-      }
-      const currentDigest = await this.digestDurableFile(relativePath);
-      const landed = pendingWriteHasLanded(view);
-      if (options?.onlyWithWriteEvidence && !landed) {
-        return "reserved";
-      }
-      if (view.expectedDigest !== void 0 && currentDigest === view.expectedDigest) {
-        await this.writeShard(shardPath, relativePath, view.revision, lock, "committed", void 0, {
-          committedDigest: view.expectedDigest,
-          committedSemanticFingerprint: await this.semanticFingerprintDurableFile(relativePath)
-        });
-        return "committed";
-      }
-      if (options?.onlyWithWriteEvidence) {
-        const evidence2 = view.expectedDigest === void 0 ? "the pending marker carries no crash evidence (written by an older version)" : "the durable file matches neither the expected commit fingerprint nor the reserve-time baseline";
-        throw new Error(
-          `CAS revision recovery for ${relativePath} is ambiguous: ${evidence2} (pending token ${view.revision}${view.previous !== void 0 ? `, previous ${view.previous}` : ""}). Inspect the durable file and the shard at ${shardPath}, then run reconcilePendingRevision with the known write outcome. Refusing to guess.`
-        );
-      }
-      if (view.baselineDigest !== void 0 && currentDigest === view.baselineDigest) {
-        if (view.previous !== void 0) {
-          await this.writeShard(shardPath, relativePath, view.previous, lock, "committed");
-        } else {
-          await unlink2(shardPath);
-        }
-        return "aborted";
-      }
-      const evidence = view.baselineDigest === void 0 && view.expectedDigest === void 0 ? "the pending marker carries no crash evidence (written by an older version)" : "the durable file matches neither the expected commit fingerprint nor the reserve-time baseline";
-      throw new Error(
-        `CAS revision recovery for ${relativePath} is ambiguous: ${evidence} (pending token ${view.revision}${view.previous !== void 0 ? `, previous ${view.previous}` : ""}). Inspect the durable file and the shard at ${shardPath}, then run reconcilePendingRevision with the known write outcome. Refusing to guess.`
-      );
-    });
-  }
-};
-
-// src/storage/cas-revision-host.ts
-var CasRevisionHost = class extends CasRevisionStore {
-  /** Standing CAS revision token — receipt identity, never public `updated` (#2807). Fail-open on read errors. */
-  async readCasRevision(filePath) {
-    try {
-      return await this.readRevision(filePath);
-    } catch (err) {
-      log.warn(`storage.readCasRevision failed for ${filePath}: ${err}`);
-      return void 0;
-    }
-  }
-  /** #2813 (P1 A): truthful CAS receipt probe — distinguishes a genuinely
-   * ABSENT receipt (target predates the sidecar; `undefined` semantics stay
-   * correct) from an UNAVAILABLE one (unreadable shard: receipt identity is
-   * unknown). Transactional callers that must refuse on unknown identity
-   * route here; `readCasRevision` stays fail-open for advisory reads.
-   * #2807 (P1): a PENDING marker left by a crash is lazily recovered on
-   * this first read when its evidence is decisive; a reserve-only marker
-   * may belong to a live writer and defers to the path-locked write path,
-   * and ambiguity stays `unavailable` with an actionable reason. */
-  async readCasRevisionStatus(filePath) {
-    const status = await this.readRevisionStatus(filePath);
-    if (status.status !== "unavailable" || !/pending/i.test(status.reason)) return status;
-    try {
-      const outcome = await this.recoverPendingRevision(filePath, {
-        onlyWithWriteEvidence: true
-      });
-      if (outcome === "reserved") return status;
-    } catch (error) {
-      return {
-        status: "unavailable",
-        reason: error instanceof Error ? error.message : String(error)
-      };
-    }
-    return await this.readRevisionStatus(filePath);
-  }
-  async readDurableFileDigest(filePath) {
-    try {
-      return await this.digestDurableFile(filePath);
-    } catch (err) {
-      log.warn(`storage.readDurableFileDigest failed for ${filePath}: ${err}`);
-      return null;
-    }
-  }
-  /** #2807 (P1): reconcile any crash-orphaned PENDING marker for this
-   * target BEFORE the next semantic mutation reserves a new token —
-   * otherwise a crashed reservation would make the memory permanently
-   * unwritable. Decisive evidence heals; ambiguity throws so the
-   * mutation fails closed with the actionable recovery error. */
-  async beginRevision(pathname, expectedContent) {
-    await this.recoverPendingRevision(pathname);
-    return await this.beginRevisionTransaction(pathname, expectedContent);
-  }
-};
-
 // src/storage/identity-continuity-store.ts
 import { readdir as readdir3 } from "fs/promises";
-import path7 from "path";
+import path6 from "path";
 var IdentityContinuityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -2910,7 +2375,7 @@ var IdentityContinuityStore = class {
     const date = nowIso.slice(0, 10);
     const id = this.deps.generateId("incident");
     const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path7.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
+    const filePath = path6.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
     await this.deps.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
     return { ...incident, filePath };
   }
@@ -2923,7 +2388,7 @@ var IdentityContinuityStore = class {
       const incidents = [];
       for (const file of candidates) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path7.join(this.deps.identityIncidentsDir, file);
+        const filePath = path6.join(this.deps.identityIncidentsDir, file);
         try {
           const raw = await this.deps.readStorageSecureFile(filePath);
           const parsed = parseContinuityIncident(raw);
@@ -2954,7 +2419,7 @@ var IdentityContinuityStore = class {
     await this.deps.ensureDirectories();
     const safeKey = this.sanitizeIdentityAuditKey(key);
     const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-    const filePath = path7.join(dir, `${safeKey}.md`);
+    const filePath = path6.join(dir, `${safeKey}.md`);
     await this.deps.writeStorageSecureFile(filePath, content);
     return filePath;
   }
@@ -2962,7 +2427,7 @@ var IdentityContinuityStore = class {
     try {
       const safeKey = this.sanitizeIdentityAuditKey(key);
       const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-      return await this.deps.readStorageSecureFile(path7.join(dir, `${safeKey}.md`));
+      return await this.deps.readStorageSecureFile(path6.join(dir, `${safeKey}.md`));
     } catch (err) {
       if (err instanceof Error && err.message === "Invalid identity audit key") return null;
       if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -3018,12 +2483,12 @@ var IdentityContinuityStore = class {
     const fileNames = await this.readContinuityIncidentFileNames();
     const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
     if (directMatch) {
-      const directPath = path7.join(this.deps.identityIncidentsDir, directMatch);
+      const directPath = path6.join(this.deps.identityIncidentsDir, directMatch);
       const parsed = await this.readContinuityIncidentFile(directPath);
       if (parsed?.id === id) return directPath;
     }
     for (const fileName of fileNames) {
-      const filePath = path7.join(this.deps.identityIncidentsDir, fileName);
+      const filePath = path6.join(this.deps.identityIncidentsDir, fileName);
       const parsed = await this.readContinuityIncidentFile(filePath);
       if (parsed?.id === id) return filePath;
     }
@@ -3039,19 +2504,19 @@ var IdentityContinuityStore = class {
 };
 
 // src/storage/entity-canonical-id-migration.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import {
   access,
   lstat as lstat2,
-  readFile as readFile2,
+  readFile,
   readdir as readdir4,
   realpath as realpath2,
-  rename as rename2,
+  rename,
   stat as statFile,
-  unlink as unlink3,
+  unlink as unlink2,
   writeFile
 } from "fs/promises";
-import path8 from "path";
+import path7 from "path";
 import { z } from "zod";
 var ENTITY_CANONICAL_ID_MIGRATION_VERSION = 1;
 var ENTITY_CANONICAL_ID_MIGRATION_LOCK_STALE_MS = 6e4;
@@ -3085,16 +2550,16 @@ async function fingerprintPath(filePath) {
 async function fingerprintEntityEntries(entitiesDir) {
   let names;
   try {
-    names = (await readdir4(entitiesDir)).filter((name) => path8.extname(name) === ".md").sort();
+    names = (await readdir4(entitiesDir)).filter((name) => path7.extname(name) === ".md").sort();
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return "missing";
     throw error;
   }
-  const hash = createHash2("sha256");
+  const hash = createHash("sha256");
   for (const name of names) {
     hash.update(`${name.length}:${name}:`);
     try {
-      const entry = await lstat2(path8.join(entitiesDir, name), { bigint: true });
+      const entry = await lstat2(path7.join(entitiesDir, name), { bigint: true });
       hash.update(`${entry.dev}:${entry.ino}:${entry.size}:${entry.mtimeNs}:${entry.ctimeNs}`);
     } catch (error) {
       if (!isErrnoCode(error, "ENOENT")) throw error;
@@ -3114,9 +2579,9 @@ async function getFingerprint(baseDir, entitiesDir, getEntityMutationVersion) {
   ] = await Promise.all([
     fingerprintPath(entitiesDir),
     fingerprintEntityEntries(entitiesDir),
-    fingerprintPath(path8.join(baseDir, "config", "aliases.json")),
-    fingerprintPath(path8.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
-    fingerprintPath(path8.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
+    fingerprintPath(path7.join(baseDir, "config", "aliases.json")),
+    fingerprintPath(path7.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
+    fingerprintPath(path7.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
   ]);
   return [
     entityDirectoryFingerprint,
@@ -3142,8 +2607,8 @@ async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
   const roots = [
     entitiesDir,
     stateDir,
-    ...RECALL_FALLBACK_DIRS.map((directory) => path8.join(baseDir, directory)),
-    path8.join(baseDir, "cold"),
+    ...RECALL_FALLBACK_DIRS.map((directory) => path7.join(baseDir, directory)),
+    path7.join(baseDir, "cold"),
     archiveDir
   ];
   for (const root of roots) {
@@ -3161,7 +2626,7 @@ async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
   }
 }
 function statePath(deps) {
-  return path8.join(deps.stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE);
+  return path7.join(deps.stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE);
 }
 async function assertSafeMigrationStateFile(deps) {
   const migrationStatePath = statePath(deps);
@@ -3204,13 +2669,13 @@ async function assertSafeTombstoneFile(deps, tombstonePath) {
   return true;
 }
 function lockPath(deps) {
-  return path8.join(deps.stateDir, "entity-canonical-id-migration.lock");
+  return path7.join(deps.stateDir, "entity-canonical-id-migration.lock");
 }
 async function readState(deps) {
   await assertSafeMigrationStateFile(deps);
   let raw;
   try {
-    raw = await readFile2(statePath(deps), "utf-8");
+    raw = await readFile(statePath(deps), "utf-8");
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return null;
     throw error;
@@ -3233,13 +2698,13 @@ async function readState(deps) {
 }
 async function writeState(deps, state) {
   const destination = statePath(deps);
-  const temporary = `${destination}.${process.pid}.${randomUUID2()}.tmp`;
+  const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
   try {
     await writeFile(temporary, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
-    await rename2(temporary, destination);
+    await rename(temporary, destination);
   } finally {
-    await unlink3(temporary).catch(() => void 0);
+    await unlink2(temporary).catch(() => void 0);
   }
 }
 async function publishState(deps, state) {
@@ -3302,7 +2767,7 @@ async function readSafeEntityEntries(entitiesDir) {
   }
   const entries = await readdir4(entitiesDir);
   for (const entry of entries) {
-    await assertNotSymlink(path8.join(entitiesDir, entry), entry);
+    await assertNotSymlink(path7.join(entitiesDir, entry), entry);
   }
   return entries;
 }
@@ -3364,7 +2829,7 @@ async function rewriteReferences(deps, mappings, refreshLock) {
     const seenPaths = /* @__PURE__ */ new Set();
     let rewroteAny = false;
     for (const memory of [...hotMemories, ...coldMemories, ...archivedMemories]) {
-      const memoryPath = path8.resolve(memory.path);
+      const memoryPath = path7.resolve(memory.path);
       if (seenPaths.has(memoryPath)) continue;
       seenPaths.add(memoryPath);
       const previousEntityRef = memory.frontmatter.entityRef;
@@ -3396,7 +2861,7 @@ async function rewriteReferences(deps, mappings, refreshLock) {
         latestCanonicalId
       );
       rewroteAny = true;
-      rewroteColdMemory ||= latestMemory.path.includes(`${path8.sep}cold${path8.sep}`);
+      rewroteColdMemory ||= latestMemory.path.includes(`${path7.sep}cold${path7.sep}`);
     }
     if (!rewroteAny) return { rewroteColdMemory };
   }
@@ -3435,7 +2900,7 @@ function rewriteTombstoneLine(line, mappings, normalizedMappings) {
   return changed ? JSON.stringify(tombstone) : line;
 }
 async function rewriteTombstoneReferences(deps, mappings, refreshLock) {
-  const tombstonePath = path8.join(deps.stateDir, "tombstones.jsonl");
+  const tombstonePath = path7.join(deps.stateDir, "tombstones.jsonl");
   const normalizedMappings = /* @__PURE__ */ new Map();
   for (const [legacyId, canonicalId] of Object.entries(mappings)) {
     const normalizedLegacyId = normalizeSupersessionKey(legacyId);
@@ -3444,7 +2909,7 @@ async function rewriteTombstoneReferences(deps, mappings, refreshLock) {
     }
   }
   await withHeldFileLock(
-    path8.join(deps.stateDir, "tombstones.lock"),
+    path7.join(deps.stateDir, "tombstones.lock"),
     {
       staleMs: TOMBSTONE_LOCK_STALE_MS,
       maxWaitMs: TOMBSTONE_LOCK_MAX_WAIT_MS
@@ -3632,7 +3097,7 @@ async function migrateEntityFilePair(deps, legacyId, canonicalId, refreshMigrati
       await deps.snapshotBeforeWrite(legacyPath, "write");
       await assertNotSymlink(legacyPath, legacyId);
       await assertEntityContentUnchanged(deps, legacyPath, legacyContent, legacyId);
-      await unlink3(legacyPath);
+      await unlink2(legacyPath);
       return { deferred: false, progressed: true };
     }
     if (!legacyExists) return { deferred: false, progressed: false };
@@ -3656,13 +3121,13 @@ async function migrateEntityFilePair(deps, legacyId, canonicalId, refreshMigrati
       await deps.snapshotBeforeWrite(legacyPath, "write");
       await assertNotSymlink(legacyPath, legacyId);
       await assertEntityContentUnchanged(deps, legacyPath, entityContent, legacyId);
-      await unlink3(legacyPath);
+      await unlink2(legacyPath);
     } catch (error) {
       if (!canonicalExists && canonicalFingerprintAfterWrite !== null) {
         try {
           if (await fingerprintPath(canonicalPath) === canonicalFingerprintAfterWrite) {
             await assertNotSymlink(canonicalPath, canonicalId);
-            await unlink3(canonicalPath);
+            await unlink2(canonicalPath);
           }
         } catch {
         }
@@ -3683,12 +3148,12 @@ async function migrateLegacyEntityCanonicalIds(deps) {
       if (!acquired) throw new Error("Timed out waiting for active entity canonical-id migration.");
       await deps.validateMemoryScanRoots?.();
       await readSafeEntityEntries(deps.entitiesDir);
-      const reconcileMarkerPath = path8.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);
-      const consumingMarkerPath = path8.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER);
+      const reconcileMarkerPath = path7.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);
+      const consumingMarkerPath = path7.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER);
       let reconcileRequested = await fileExists(consumingMarkerPath);
       if (await fileExists(reconcileMarkerPath)) {
         try {
-          await rename2(reconcileMarkerPath, consumingMarkerPath);
+          await rename(reconcileMarkerPath, consumingMarkerPath);
           reconcileRequested = true;
         } catch (error) {
           if (!isErrnoCode(error, "ENOENT")) throw error;
@@ -3711,7 +3176,7 @@ async function migrateLegacyEntityCanonicalIds(deps) {
           );
         }
         if (reconcileRequested) {
-          await unlink3(consumingMarkerPath).catch((error) => {
+          await unlink2(consumingMarkerPath).catch((error) => {
             if (!isErrnoCode(error, "ENOENT")) throw error;
           });
         }
@@ -3857,7 +3322,7 @@ async function migrateLegacyEntityCanonicalIds(deps) {
 }
 
 // src/storage/entity-ref-repair.ts
-import { unlink as unlink4 } from "fs/promises";
+import { unlink as unlink3 } from "fs/promises";
 var EntityRefRepair = class {
   constructor(deps) {
     this.deps = deps;
@@ -3919,7 +3384,7 @@ ${body}
       if (opts.onFailRestore) {
         await this.restore(opts.onFailRestore);
       } else if (opts.onFailRemove) {
-        await unlink4(opts.onFailRemove).catch(() => void 0);
+        await unlink3(opts.onFailRemove).catch(() => void 0);
         this.deps.invalidateAllMemoriesCache();
       }
       throw err;
@@ -4080,7 +3545,7 @@ import {
   readFileSync,
   realpathSync
 } from "fs";
-import path9 from "path";
+import path8 from "path";
 function resolveSafeAliasRoots(baseDir, configDir) {
   let baseStat;
   try {
@@ -4107,8 +3572,8 @@ function resolveSafeAliasRoots(baseDir, configDir) {
   return memoryRoot;
 }
 function readEntityAliasConfigSync(baseDir) {
-  const configDir = path9.join(baseDir, "config");
-  const aliasPath = path9.join(configDir, "aliases.json");
+  const configDir = path8.join(baseDir, "config");
+  const aliasPath = path8.join(configDir, "aliases.json");
   let memoryRoot = resolveSafeAliasRoots(baseDir, configDir);
   if (memoryRoot === void 0) return void 0;
   let aliasPreflight;
@@ -4169,7 +3634,7 @@ function decodeYamlScalar(value) {
 }
 
 // src/orchestration/qmd-result-resolver.ts
-import path10 from "path";
+import path9 from "path";
 var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
   ...ALL_CATEGORY_DIRS,
   "activity",
@@ -4191,7 +3656,7 @@ var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
 ]);
 var PRIVATE_RESULT_RESOLUTION_CONCURRENCY = 16;
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path10.isAbsolute(resultPath)) return null;
+  if (!resultPath || path9.isAbsolute(resultPath)) return null;
   if (resultPath.trim().startsWith("qmd://")) {
     try {
       const parsed = new URL(resultPath.trim());
@@ -4216,9 +3681,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path10.resolve(storageDir);
+  const storageRoot = path9.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path10.resolve(candidate);
+    const resolved = path9.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -4226,18 +3691,18 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path10.join(storageRoot, normalized));
+    addCandidate(path9.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path10.join(storageRoot, "facts", normalized));
+      addCandidate(path9.join(storageRoot, "facts", normalized));
     }
   };
-  if (path10.isAbsolute(resultPath)) {
+  if (path9.isAbsolute(resultPath)) {
     addCandidate(resultPath);
-    const relative2 = path10.relative(storageRoot, path10.resolve(resultPath));
-    if (relative2 && !relative2.startsWith("..") && !path10.isAbsolute(relative2)) {
-      const normalized = relative2.split(path10.sep).join("/");
+    const relative2 = path9.relative(storageRoot, path9.resolve(resultPath));
+    if (relative2 && !relative2.startsWith("..") && !path9.isAbsolute(relative2)) {
+      const normalized = relative2.split(path9.sep).join("/");
       if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-        addCandidate(path10.join(storageRoot, "facts", normalized));
+        addCandidate(path9.join(storageRoot, "facts", normalized));
       }
     }
   } else {
@@ -4273,7 +3738,7 @@ var QmdResultResolver = class {
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir ? path10.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path9.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -4303,7 +3768,7 @@ var QmdResultResolver = class {
           continue;
         }
         try {
-          const coldRoot = path10.join(storageDir, "cold");
+          const coldRoot = path9.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(coldRoot, parts.relativePath)) {
             const memory = await storage.readMemoryByPath(candidate);
             if (memory) return memory;
@@ -4353,9 +3818,9 @@ var QmdResultResolver = class {
           error: err.message
         });
       }
-      if (!path10.isAbsolute(fallbackResultPath)) return null;
+      if (!path9.isAbsolute(fallbackResultPath)) return null;
     }
-    if (path10.isAbsolute(fallbackResultPath)) {
+    if (path9.isAbsolute(fallbackResultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(fallbackResultPath);
       }
@@ -4412,17 +3877,17 @@ var QmdResultResolver = class {
     if (!memory && parts && !collectionIsKnownInternal && !collectionIsConfigured) {
       memory = await this.readQmdResultMemory(parts.relativePath, fallbackStorage, namespaces, result.namespace);
     }
-    const absoluteInsideMemoryRoot = path10.isAbsolute(result.path) && isPathInsideStorageRoot(path10.resolve(config.memoryDir), path10.resolve(result.path));
+    const absoluteInsideMemoryRoot = path9.isAbsolute(result.path) && isPathInsideStorageRoot(path9.resolve(config.memoryDir), path9.resolve(result.path));
     const hasExplicitQmdCollection = result.path.trim().startsWith("qmd://");
     const unresolvedInternalPath = !memory && (absoluteInsideMemoryRoot || collectionIsKnownInternal && (!preserveUnresolved || hasExplicitQmdCollection) || hasExplicitQmdCollection && collectionIsConfigured);
-    const unresolvedExternalCollection = !memory && (parts !== null && !collectionIsKnownInternal && !collectionIsConfigured || path10.isAbsolute(result.path) && !isPathInsideStorageRoot(path10.resolve(config.memoryDir), path10.resolve(result.path)));
+    const unresolvedExternalCollection = !memory && (parts !== null && !collectionIsKnownInternal && !collectionIsConfigured || path9.isAbsolute(result.path) && !isPathInsideStorageRoot(path9.resolve(config.memoryDir), path9.resolve(result.path)));
     return memory !== null && !isSupportPassportPrivateMemory(memory) || !memory && !unresolvedInternalPath && (preserveUnresolved || unresolvedExternalCollection);
   }
   async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
     const memory = await this.readQmdResultMemory(result.path, fallbackStorage, recallNamespaces, result.namespace);
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path10.isAbsolute(memory.path)) {
+    if (path9.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(memory.path, fallbackStorage, recallNamespaces);
       ownerNamespace = ownerStorage?.namespace ?? null;
       if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
@@ -4443,17 +3908,17 @@ var QmdResultResolver = class {
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path10.resolve(resultPath);
+    const resolvedPath = path9.resolve(resultPath);
     const config = this.getConfig();
-    const memoryRoot = path10.resolve(config.memoryDir);
-    const namespacesRoot = path10.join(memoryRoot, "namespaces");
+    const memoryRoot = path9.resolve(config.memoryDir);
+    const namespacesRoot = path9.join(memoryRoot, "namespaces");
     const fallbackStorageDir = storageDirOrNull(fallbackStorage);
     const matches = [];
     const seenDirs = /* @__PURE__ */ new Set();
     const maybeAddStorage = (storage, namespace) => {
       const storageDir = storageDirOrNull(storage);
       if (!storageDir) return;
-      const candidateRoot = path10.resolve(storageDir);
+      const candidateRoot = path9.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -4471,7 +3936,7 @@ var QmdResultResolver = class {
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path10.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path9.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment);
@@ -5012,7 +4477,7 @@ function collectSpeakers(tagged) {
 }
 
 // src/wearables/fusion/fuse.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var FUSION_ID_PREFIX = "fusion";
 var FUSION_ALGO_VERSION = "2026-07-12-1";
 function canonicalInputsKey(date, inputs) {
@@ -5041,7 +4506,7 @@ function canonicalInputsKey(date, inputs) {
       ])
     ])
   ];
-  return createHash3("sha256").update(JSON.stringify(record), "utf-8").digest("hex");
+  return createHash2("sha256").update(JSON.stringify(record), "utf-8").digest("hex");
 }
 function configFingerprint(options, sources) {
   const proximityGapMs = options.proximityGapMs ?? DEFAULT_PROXIMITY_GAP_MS;
@@ -5056,7 +4521,7 @@ function canonicalDayKey(date, inputs, options, algoVersion = FUSION_ALGO_VERSIO
     options,
     inputs.map((conv) => conv.source)
   );
-  return createHash3("sha256").update(inputsKey).update("\n").update(fingerprint).update("\n").update(algoVersion).digest("hex");
+  return createHash2("sha256").update(inputsKey).update("\n").update(fingerprint).update("\n").update(algoVersion).digest("hex");
 }
 function buildProvenance(cluster, proximityGapMs, windowToleranceMs) {
   return {
@@ -5116,11 +4581,11 @@ function fuseDay(date, inputs, options = {}) {
 }
 
 // src/wearables/fusion/store.ts
-import { createHash as createHash4 } from "crypto";
-import * as path11 from "path";
+import { createHash as createHash3 } from "crypto";
+import * as path10 from "path";
 var FUSION_KIND = "wearable-fusion";
 function hashFusionBody(conversations) {
-  return createHash4("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
+  return createHash3("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
 }
 function composeFusionDayMeta(date, conversations, sources, contentHash, fusedAt) {
   return {
@@ -5304,7 +4769,7 @@ var FusionArtifactStore = class {
         `invalid wearable fusion date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path11.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
+    return path10.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
   }
   async writeFusedDay(date, serialized) {
     const filePath = this.fusedDayPath(date);
@@ -5341,7 +4806,7 @@ var FusionArtifactStore = class {
   }
   /** List dates with stored fused artifacts, newest first. */
   async listFusedDays() {
-    const fusionDir = path11.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path10.join(this.wearablesDir, FUSION_DIR_NAME);
     await this.assertPathContained(fusionDir);
     let entries;
     try {
@@ -5385,10 +4850,10 @@ var FusionArtifactStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path11.resolve(this.memoryDir);
+      rootReal = path10.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.wearablesDir);
-    await this.assertNoEscape(rootReal, path11.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path10.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertFusionDirNotSymlinked();
   }
@@ -5402,7 +4867,7 @@ var FusionArtifactStore = class {
    * (a fresh write creates a real directory lexically under the root).
    */
   async assertFusionDirNotSymlinked() {
-    const fusionDir = path11.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path10.join(this.wearablesDir, FUSION_DIR_NAME);
     let stat4;
     try {
       stat4 = await this.io.lstat(fusionDir);
@@ -5537,8 +5002,8 @@ function reconstructFusionInputs(date, dayTranscripts) {
 }
 
 // src/meetings/store.ts
-import { createHash as createHash5 } from "crypto";
-import * as path12 from "path";
+import { createHash as createHash4 } from "crypto";
+import * as path11 from "path";
 var MEETINGS_DIR_NAME = "meetings";
 var MEETING_KIND = "meeting";
 var MEETING_FORMAT_VERSION = 1;
@@ -5568,7 +5033,7 @@ function canonicalContent(base, fused) {
   });
 }
 function composeMeetingRecord(base, fused) {
-  const contentHash = createHash5("sha256").update(canonicalContent(base, fused), "utf-8").digest("hex");
+  const contentHash = createHash4("sha256").update(canonicalContent(base, fused), "utf-8").digest("hex");
   return {
     ...base,
     ...fused,
@@ -5707,7 +5172,7 @@ var MeetingRecordStore = class {
   constructor(memoryDir, io) {
     this.memoryDir = memoryDir;
     this.io = io;
-    this.meetingsDir = path12.join(memoryDir, MEETINGS_DIR_NAME);
+    this.meetingsDir = path11.join(memoryDir, MEETINGS_DIR_NAME);
   }
   memoryDir;
   io;
@@ -5723,7 +5188,7 @@ var MeetingRecordStore = class {
     if (idDate !== date) {
       throw new Error(`meeting id '${id}' does not belong to date '${date}'`);
     }
-    return path12.join(this.meetingsDir, date, `${id}.md`);
+    return path11.join(this.meetingsDir, date, `${id}.md`);
   }
   /** Idempotently persist a record: skip the write when contentHash is unchanged. */
   async saveMeetingRecord(record) {
@@ -5754,7 +5219,7 @@ var MeetingRecordStore = class {
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid meeting date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    const dayDir = path12.join(this.meetingsDir, date);
+    const dayDir = path11.join(this.meetingsDir, date);
     await this.assertPathContained(dayDir);
     let entries;
     try {
@@ -5822,10 +5287,10 @@ var MeetingRecordStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path12.resolve(this.memoryDir);
+      rootReal = path11.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.meetingsDir);
-    await this.assertNoEscape(rootReal, path12.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path11.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertNotSymlink(this.meetingsDir, "directory");
     const dayDir = this.dayDirWithin(targetPath);
@@ -5835,11 +5300,11 @@ var MeetingRecordStore = class {
   /** The `<meetings>/<date>` directory on the path to `targetPath`, or null when
    *  `targetPath` is the meetings root itself. */
   dayDirWithin(targetPath) {
-    const rel = path12.relative(this.meetingsDir, targetPath);
-    if (rel === "" || rel.startsWith("..") || path12.isAbsolute(rel)) return null;
-    const first = rel.split(path12.sep)[0];
+    const rel = path11.relative(this.meetingsDir, targetPath);
+    if (rel === "" || rel.startsWith("..") || path11.isAbsolute(rel)) return null;
+    const first = rel.split(path11.sep)[0];
     if (first === void 0 || first.length === 0) return null;
-    return path12.join(this.meetingsDir, first);
+    return path11.join(this.meetingsDir, first);
   }
   async assertNotSymlink(target, kind) {
     let stat4;
@@ -5850,7 +5315,7 @@ var MeetingRecordStore = class {
       throw err;
     }
     if (stat4.isSymbolicLink) {
-      const label = path12.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
+      const label = path11.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
       throw new Error(
         `meetings ${kind} '${label}' is a symbolic link \u2014 refusing to follow it even when it resolves inside the memory dir (AGENTS.md pattern #3)`
       );
@@ -5874,7 +5339,7 @@ var SORT_STR = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 
 // src/storage/supersession-audit.ts
 import { readdir as readdir5 } from "fs/promises";
-import path13 from "path";
+import path12 from "path";
 async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody, structuredAttributes) {
   let entries;
   try {
@@ -5885,7 +5350,7 @@ async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody,
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const memory = await lookup.readMemoryByPath(path13.join(lookup.correctionsDir, entry.name));
+    const memory = await lookup.readMemoryByPath(path12.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
     ))) {
@@ -5975,7 +5440,7 @@ Reason: ${reason}`;
 }
 
 // src/storage/entity-timeline.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var ENTITY_TIMELINE_METADATA_MARKER = "remnic-meta-v1";
 function parseEntityTimelineBullet(bullet, fallbackTimestamp) {
   const trimmed = bullet.trim();
@@ -6417,7 +5882,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 createHash6("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
 }
 function isEntitySynthesisStale(entity) {
   const structuredFactCount = countEntityStructuredFacts(entity);
@@ -6974,17 +6439,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path14.basename(pathRel, ".md").toLowerCase();
+  const basename = path13.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(path14.sep).join("/");
+  const normalizedPath = pathRel.split(path13.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path14.basename(pathRel, ".md");
+    const basename = path13.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -7457,9 +6922,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.entitySchemas = entitySchemas;
     this.deletionRevisionStore = new DeletionRevisionStore({
       baseDir,
-      deletionRevisionMetadataPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
-      invalidationCommitMetadataPath: path14.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
-      deletionRevisionLockPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
+      deletionRevisionMetadataPath: path13.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
+      invalidationCommitMetadataPath: path13.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
+      deletionRevisionLockPath: path13.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
       assertManagedStoragePath: (filePath, method) => this.assertManagedStoragePath(filePath, method)
     });
     this.casRevisions = new CasRevisionHost(baseDir);
@@ -7645,8 +7110,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path14.relative(this.stateDir, path14.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel);
+    const rel = path13.relative(this.stateDir, path13.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path13.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -7761,8 +7226,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path14.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path14.sep}`) || rel.startsWith(`archive${path14.sep}`);
+    const rel = path13.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path13.sep}`) || rel.startsWith(`archive${path13.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -7849,7 +7314,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         void 0,
         this.baseDir
       );
-      const rel = path14.relative(this.baseDir, filePath).split(path14.sep).join("/");
+      const rel = path13.relative(this.baseDir, filePath).split(path13.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -7894,10 +7359,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     _StorageManager.okfConformanceByDir.set(memoryDir, enabled !== false);
   }
   okfConformanceEnabled() {
-    for (let dir = this.baseDir; ; dir = path14.dirname(dir)) {
+    for (let dir = this.baseDir; ; dir = path13.dirname(dir)) {
       const registered = _StorageManager.okfConformanceByDir.get(dir);
       if (registered !== void 0) return registered;
-      if (dir === path14.dirname(dir)) return true;
+      if (dir === path13.dirname(dir)) return true;
     }
   }
   /**
@@ -7944,12 +7409,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path14.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path13.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path14.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path13.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    return path14.join(this.stateDir, `.${kind}-version.log`);
+    return path13.join(this.stateDir, `.${kind}-version.log`);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -8053,7 +7518,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path14.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path13.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -8069,7 +7534,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 path14.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path13.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -8096,7 +7561,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       writeFile: (p, c) => this.writeStorageSecureFile(p, c),
       readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
       readDir: (d) => readdir6(d),
-      deleteFile: (p) => unlink5(p),
+      deleteFile: (p) => unlink4(p),
       realpath: (p) => realpath3(p),
       lstat: (p) => lstat3(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
@@ -8114,7 +7579,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       writeFile: (p, c) => this.writeStorageSecureFile(p, c),
       readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
       readDir: (d) => readdir6(d),
-      deleteFile: (p) => unlink5(p),
+      deleteFile: (p) => unlink4(p),
       realpath: (p) => realpath3(p),
       lstat: (p) => lstat3(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
@@ -8185,25 +7650,25 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   get factsDir() {
-    return path14.join(this.baseDir, "facts");
+    return path13.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path14.join(this.baseDir, "corrections");
+    return path13.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path14.join(this.baseDir, "procedures");
+    return path13.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path14.join(this.baseDir, "reasoning-traces");
+    return path13.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path14.join(this.baseDir, "entities");
+    return path13.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path14.resolve(this.entitiesDir, `${name}.md`);
-    const relative2 = path14.relative(this.entitiesDir, filePath);
-    if (relative2 === "" || relative2.startsWith("..") || path14.isAbsolute(relative2)) {
+    const filePath = path13.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path13.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path13.isAbsolute(relative2)) {
       return null;
     }
     return filePath;
@@ -8214,7 +7679,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readDependencyPropagationQueueFile(filePath) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path14.relative(
+      path13.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.readDependencyPropagationQueueFile")
       )
@@ -8224,7 +7689,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async writeDependencyPropagationQueueFile(filePath, content) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path14.relative(
+      path13.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.writeDependencyPropagationQueueFile")
       )
@@ -8239,10 +7704,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path14.resolve(filePath);
-    const base = path14.resolve(this.baseDir);
-    const rel = path14.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path14.sep}`) || path14.isAbsolute(rel)) {
+    const resolved = path13.resolve(filePath);
+    const base = path13.resolve(this.baseDir);
+    const rel = path13.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path13.sep}`) || path13.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -8269,7 +7734,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async writeManagedStorageFile(filePath, write) {
     return this.deletionRevisionStore.writeManagedStorageFile(filePath, write);
   }
-  async deleteManagedStorageFile(filePath, deletionMtimeMs) {
+  async deleteManagedStorageFileDurable(filePath, deletionMtimeMs) {
     return this.deletionRevisionStore.deleteManagedStorageFile(filePath, deletionMtimeMs);
   }
   async readOfflineSyncFile(filePath) {
@@ -8279,7 +7744,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path14.relative(this.baseDir, target).split(path14.sep).join("/");
+    const relPath = path13.relative(this.baseDir, target).split(path13.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) {
@@ -8293,11 +7758,11 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     if (encrypted) {
       const content = await readMaybeEncryptedFileBuffer(target, this._secureStoreKey, this.baseDir);
       digest = {
-        sha256: createHash7("sha256").update(content).digest("hex"),
+        sha256: createHash6("sha256").update(content).digest("hex"),
         bytes: content.byteLength
       };
     } else {
-      const hash = createHash7("sha256");
+      const hash = createHash6("sha256");
       let bytes = 0;
       for await (const rawChunk of createReadStream(target)) {
         const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
@@ -8325,7 +7790,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readOfflineSyncDigestCache() {
     const cache = /* @__PURE__ */ new Map();
     try {
-      const raw = await readFile3(this.offlineSyncDigestCachePath, "utf-8");
+      const raw = await readFile2(this.offlineSyncDigestCachePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return cache;
       const entries = parsed.entries;
@@ -8340,7 +7805,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         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("../") || path14.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("../") || path13.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 });
@@ -8382,7 +7847,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(path14.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir(path13.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile2(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -8392,7 +7857,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   async offlineSyncFileIsEncrypted(filePath) {
-    const handle = await open2(filePath, "r");
+    const handle = await open(filePath, "r");
     try {
       const header = Buffer.alloc(MAGIC_HEADER_SIZE);
       const { bytesRead } = await handle.read(header, 0, header.length, 0);
@@ -8451,7 +7916,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     }
     let handle;
     try {
-      handle = await open2(filePath, "r");
+      handle = await open(filePath, "r");
     } catch (err) {
       if (isErrnoCode(err, "ENOENT")) return false;
       throw err;
@@ -8471,7 +7936,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir2(path14.dirname(filePath), { recursive: true });
+    await mkdir(path13.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -8497,13 +7962,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path14.join(this.baseDir, "state");
+    return path13.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path14.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path13.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path14.join(this.stateDir, "entity-synthesis-queue.json");
+    return path13.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -8513,7 +7978,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path14.join(this.stateDir, "tombstones.jsonl");
+    return path13.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -8815,55 +8280,55 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return legacyMatches.length > 0 ? [...new Set(legacyMatches.map((content) => ContentHashIndex.computeHash(content)))] : [persistedHash];
   }
   get questionsDir() {
-    return path14.join(this.baseDir, "questions");
+    return path13.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path14.join(this.baseDir, "artifacts");
+    return path13.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path14.join(this.baseDir, "identity");
+    return path13.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path14.join(this.identityDir, "identity-anchor.md");
+    return path13.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path14.join(this.identityDir, "incidents");
+    return path13.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path14.join(this.identityDir, "audits", "weekly");
+    return path13.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path14.join(this.identityDir, "audits", "monthly");
+    return path13.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path14.join(this.identityDir, "improvement-loops.md");
+    return path13.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path14.join(this.identityDir, "reflections.md");
+    return path13.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path14.join(this.baseDir, "profile.md");
+    return path13.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path14.join(this.stateDir, "memory-actions.jsonl");
+    return path13.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path14.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path13.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path14.join(this.stateDir, "compression-guidelines.md");
+    return path13.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path14.join(this.stateDir, "compression-guidelines.draft.md");
+    return path13.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path14.join(this.stateDir, "compression-guideline-state.json");
+    return path13.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path14.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path13.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path14.join(this.stateDir, "behavior-signals.jsonl");
+    return path13.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -8895,7 +8360,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path14.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path13.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -8956,7 +8421,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path14.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path13.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     const raw = readEntityAliasConfigSync(this.baseDir);
     if (raw === void 0) return;
@@ -8991,22 +8456,22 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return completionFingerprint;
   }
   async ensureDirectories() {
-    await mkdir2(this.baseDir, { recursive: true });
+    await mkdir(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(path14.join(this.factsDir, today), { recursive: true });
-    await mkdir2(path14.join(this.proceduresDir, today), { recursive: true });
-    await mkdir2(path14.join(this.reasoningTracesDir, today), { recursive: true });
-    await mkdir2(this.correctionsDir, { recursive: true });
-    await mkdir2(this.entitiesDir, { recursive: true });
-    await mkdir2(this.stateDir, { recursive: true });
-    await mkdir2(this.questionsDir, { recursive: true });
-    await mkdir2(this.artifactsDir, { recursive: true });
-    await mkdir2(this.identityDir, { recursive: true });
-    await mkdir2(this.identityIncidentsDir, { recursive: true });
-    await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
-    await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir2(path14.join(this.baseDir, "config"), { recursive: true });
+    await mkdir(path13.join(this.factsDir, today), { recursive: true });
+    await mkdir(path13.join(this.proceduresDir, today), { recursive: true });
+    await mkdir(path13.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir(this.correctionsDir, { recursive: true });
+    await mkdir(this.entitiesDir, { recursive: true });
+    await mkdir(this.stateDir, { recursive: true });
+    await mkdir(this.questionsDir, { recursive: true });
+    await mkdir(this.artifactsDir, { recursive: true });
+    await mkdir(this.identityDir, { recursive: true });
+    await mkdir(this.identityIncidentsDir, { recursive: true });
+    await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
+    await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
+    await mkdir(path13.join(this.baseDir, "config"), { recursive: true });
     await this.entityCanonicalIdMigration.ensure();
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
@@ -9027,12 +8492,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    */
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
-      await mkdir2(this.correctionsDir, { recursive: true });
-      return path14.join(this.correctionsDir, `${id}.md`);
+      await mkdir(this.correctionsDir, { recursive: true });
+      return path13.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path14.join(getCategoryDir(this.baseDir, category), today);
-    await mkdir2(datedDir, { recursive: true });
-    return path14.join(datedDir, `${id}.md`);
+    const datedDir = path13.join(getCategoryDir(this.baseDir, category), today);
+    await mkdir(datedDir, { recursive: true });
+    return path13.join(datedDir, `${id}.md`);
   }
   async findExistingTombstoneBlockedMemory(content, category, sourceConnector) {
     const identity = buildExplicitCaptureDedupKey(content, category, sourceConnector);
@@ -9203,7 +8668,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;
@@ -9419,8 +8884,8 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path14.join(this.artifactsDir, day);
-    await mkdir2(dir, { recursive: true });
+    const dir = path13.join(this.artifactsDir, day);
+    await mkdir(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
       id,
@@ -9446,7 +8911,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path14.join(dir, `${id}.md`);
+    const filePath = path13.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
@@ -9739,7 +9204,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path14.join(this.baseDir, "cold");
+    const coldRoot = path13.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -9859,7 +9324,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path14.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path13.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -9922,7 +9387,7 @@ ${sanitized.text}
       try {
         const entries = await readdir6(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path14.join(dir, entry.name);
+          const fullPath = path13.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -9965,7 +9430,7 @@ ${sanitized.text}
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path14.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path13.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -9980,13 +9445,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path14.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path13.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path14.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path13.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path14.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path13.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     assertNotOkfReservedBasename(targetPath);
@@ -10003,7 +9468,7 @@ ${memory.content}
       {},
       this.baseDir
     );
-    const priorDest = await readFile3(targetPath).catch(() => null);
+    const priorDest = await readFile2(targetPath).catch(() => null);
     await persist();
     if (typeof rawRef === "string") {
       const refBeforeRepair = frontmatter.entityRef;
@@ -10018,7 +9483,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);
         }
@@ -10065,8 +9530,8 @@ ${memory.content}
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
             durable = true;
-            const sourcePath = path14.resolve(current.path);
-            const destPath = path14.resolve(targetPath);
+            const sourcePath = path13.resolve(current.path);
+            const destPath = path13.resolve(targetPath);
             if (sourcePath !== destPath) {
               await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
@@ -10090,8 +9555,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path14.resolve(memory.path);
-    const destPath = path14.resolve(targetPath);
+    const sourcePath = path13.resolve(memory.path);
+    const destPath = path13.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -10101,7 +9566,7 @@ ${memory.content}
     return { changed, targetPath };
   }
   get archiveDir() {
-    return path14.join(this.baseDir, "archive");
+    return path13.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -10114,8 +9579,8 @@ ${memory.content}
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
         const today = now.toISOString().slice(0, 10);
-        const destDir = path14.join(this.archiveDir, today);
-        await mkdir2(destDir, { recursive: true });
+        const destDir = path13.join(this.archiveDir, today);
+        await mkdir(destDir, { recursive: true });
         const refIdsAtWrite = this.currentHistoricalIds();
         const updatedFm = canonicalizeEntityRefOption(
           {
@@ -10130,7 +9595,7 @@ ${memory.content}
 
 ${current.content}
 `;
-        const destPath = path14.join(destDir, path14.basename(current.path));
+        const destPath = path13.join(destDir, path13.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") {
@@ -10147,7 +9612,7 @@ ${current.content}
               await recordArchiveDelete2(
                 this.baseDir,
                 destPath,
-                () => unlink5(destPath).then(
+                () => unlink4(destPath).then(
                   () => true,
                   () => false
                 )
@@ -10361,7 +9826,7 @@ ${memory.content}
 `;
     await this.writeTombstoneBlockedFrontmatter(memory, fileContent, updated, async () => {
       this.invalidateAllMemoriesCache();
-      if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
+      if (memory.path.includes(`${path13.sep}cold${path13.sep}`)) {
         this.invalidateColdMemoriesCache();
       }
     });
@@ -10372,7 +9837,7 @@ ${memory.content}
       });
     }
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
+    if (memory.path.includes(`${path13.sep}cold${path13.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -10453,7 +9918,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path14.join(this.stateDir, "buffer.json");
+    const bufferPath = path13.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -10465,11 +9930,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path14.join(this.stateDir, "buffer.json");
+    const bufferPath = path13.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path14.join(this.stateDir, "meta.json");
+    const metaPath = path13.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -10502,7 +9967,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path14.join(this.stateDir, "meta.json");
+    const metaPath = path13.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -10572,7 +10037,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir2(path14.dirname(target), { recursive: true });
+        await mkdir(path13.dirname(target), { recursive: true });
       }
     );
   }
@@ -10670,7 +10135,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path13.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -10683,7 +10148,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path13.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -10832,7 +10297,7 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash7("sha256").update(draftContent).digest("hex");
+      const contentHash = createHash6("sha256").update(draftContent).digest("hex");
       if (contentHash !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
@@ -10841,8 +10306,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;
   }
@@ -10894,7 +10359,7 @@ ${memory.content}
     return `${prefix}-${ts}-${rand}`;
   }
   async writeQuestion(question, context, priority) {
-    await mkdir2(this.questionsDir, { recursive: true });
+    await mkdir(this.questionsDir, { recursive: true });
     const id = this.generateId("q");
     const frontmatter = {
       id,
@@ -10911,7 +10376,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path14.join(this.questionsDir, `${id}.md`);
+    const filePath = path13.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -10948,7 +10413,7 @@ ${question}
   async readIdentity(workspaceDir, namespace) {
     const identityPath = this.identityFilePath(workspaceDir, namespace);
     try {
-      return await readFile3(identityPath, "utf-8");
+      return await readFile2(identityPath, "utf-8");
     } catch {
       return "";
     }
@@ -10966,15 +10431,15 @@ ${question}
     const identityPath = this.identityFilePath(workspaceDir, opts?.namespace);
     let existing = "";
     try {
-      existing = await readFile3(identityPath, "utf-8");
+      existing = await readFile2(identityPath, "utf-8");
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path14.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path13.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path14.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path13.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -11026,7 +10491,7 @@ ${reflection}
     }
   }
   async writeIdentityReflections(content) {
-    await mkdir2(this.identityDir, { recursive: true });
+    await mkdir(this.identityDir, { recursive: true });
     await this.writeStorageSecureFile(this.identityReflectionsPath, content);
   }
   async appendIdentityReflection(reflection) {
@@ -11058,7 +10523,7 @@ ${reflection}
 
 ${reflection}
 `;
-    await mkdir2(this.identityDir, { recursive: true });
+    await mkdir(this.identityDir, { recursive: true });
     await this.writeStorageSecureFile(this.identityReflectionsPath, `${existing.trimEnd()}${section}`);
     log.debug(`appended namespace-local reflection to ${this.identityReflectionsPath}`);
   }
@@ -11114,7 +10579,7 @@ ${reflection}
       const rightTs = latestEntityTimelineTimestamp(right.entity) ?? "";
       return compareEntityTimestamps(rightTs, leftTs);
     }).map(({ entityName }) => entityName);
-    await mkdir2(this.stateDir, { recursive: true });
+    await mkdir(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       this.entitySynthesisQueuePath,
       JSON.stringify(
@@ -11134,7 +10599,7 @@ ${reflection}
     if (queue.length === 0) return;
     const removals = new Set(entityNames);
     const nextQueue = queue.filter((name) => !removals.has(name));
-    await mkdir2(this.stateDir, { recursive: true });
+    await mkdir(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       this.entitySynthesisQueuePath,
       JSON.stringify(
@@ -11234,14 +10699,14 @@ ${reflection}
     if (entries.length === 0) return 0;
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-    const memoryPathMap = new Map(memories.map((m) => [path14.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path13.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     const keyId = this.hotCacheKeyId();
     const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
     const appliedPatches = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      const memory = entry.memoryPath ? memoryPathMap.get(path14.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path13.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       try {
         const applied = await this.withTombstoneBlockedMemoryPathLock(memory.path, async (current) => {
@@ -11272,7 +10737,7 @@ ${current.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...applied.current, frontmatter: applied.newFm }, keyId);
         }
-        appliedPatches.set(path14.resolve(memory.path), {
+        appliedPatches.set(path13.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -11288,7 +10753,7 @@ ${current.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path14.resolve(m.path));
+            const patch = appliedPatches.get(path13.resolve(m.path));
             return patch ? {
               ...m,
               frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed }
@@ -11318,7 +10783,7 @@ ${current.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path14.basename(filePath, ".md");
+      const memoryId = path13.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -11330,7 +10795,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(path14.resolve(filePath)));
+        const directMatch = existingPaths.find((filePath) => directCandidates.has(path13.resolve(filePath)));
         if (directMatch) {
           preferredMatches.push(directMatch);
           continue;
@@ -11342,7 +10807,7 @@ ${current.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path14.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path13.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -11533,7 +10998,7 @@ ${sanitized.text}
     }
     if (!oldMemory) return false;
     const requireActiveAtWrite = options.requireActive === true || inferMemoryStatus(oldMemory.frontmatter, toMemoryPathRel(this.baseDir, oldMemory.path)) === "active";
-    const operationId = createHash7("sha256").update(
+    const operationId = createHash6("sha256").update(
       JSON.stringify({
         oldMemoryId,
         newMemoryId,
@@ -11662,11 +11127,11 @@ ${current.content}
     }
   }
   get summariesDir() {
-    return path14.join(this.baseDir, "summaries");
+    return path13.join(this.baseDir, "summaries");
   }
   async writeSummary(summary) {
-    await mkdir2(this.summariesDir, { recursive: true });
-    const filePath = path14.join(this.summariesDir, `${summary.id}.json`);
+    await mkdir(this.summariesDir, { recursive: true });
+    const filePath = path13.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -11676,7 +11141,7 @@ ${current.content}
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path14.join(this.summariesDir, file);
+        const filePath = path13.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -11746,8 +11211,8 @@ ${current.content}
     return archived;
   }
   async saveTopics(topics) {
-    const metaPath = path14.join(this.stateDir, "topics.json");
-    await mkdir2(this.stateDir, { recursive: true });
+    const metaPath = path13.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)
@@ -11755,7 +11220,7 @@ ${current.content}
     log.debug(`saved ${topics.length} topic scores`);
   }
   async loadTopics() {
-    const metaPath = path14.join(this.stateDir, "topics.json");
+    const metaPath = path13.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -11833,7 +11298,6 @@ export {
   serializeDriftProvenance,
   parseDriftProvenance,
   selfDeps,
-  canonicalSemanticFileText,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   QmdResultResolver,
@@ -11874,4 +11338,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-IAT5WFEU.js.map
+//# sourceMappingURL=chunk-QUFJ3NJE.js.map