@remnic/core 9.3.748 → 9.3.749

package/dist/{chunk-ZWGXZ7ID.js → chunk-PNUOQYRJ.js}

@@ -538,7 +538,7 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path12 from "path";
+import path13 from "path";
 import os2 from "os";
 import { createHash as createHash7 } from "crypto";
 import { existsSync, readFileSync } from "fs";
@@ -2168,7 +2168,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path27, c] of nsMap) counters.set(path27, c);
+        for (const [path28, c] of nsMap) counters.set(path28, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -2253,7 +2253,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path27) => {
+        readMemoryFrontmatter: async (path28) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2264,7 +2264,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
             }
           }
           if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path27, fallbackReader, namespaces);
+          const memory = await this.readQmdResultMemory(path28, fallbackReader, namespaces);
           return memory ? memory.frontmatter : null;
         }
       },
@@ -12663,6 +12663,278 @@ var OrchestratorInitCoordinator = class {
   }
 };
 
+// src/orchestration/persistence-index.ts
+import path12 from "path";
+var PersistenceIndexCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async hasContentHashDedup(targetStorage, content) {
+    const index = await this.deps.contentHashIndexForStorage(targetStorage);
+    return index ? index.has(content) : false;
+  }
+  async addContentHashDedup(targetStorage, content) {
+    const index = await this.deps.contentHashIndexForStorage(targetStorage);
+    if (!index) return;
+    index.add(content);
+  }
+  async removeContentHashForMemory(targetStorage, memory, context) {
+    const index = await this.deps.contentHashIndexForStorage(targetStorage);
+    if (!index) return;
+    if (memory.frontmatter.contentHash) {
+      index.removeByHash(memory.frontmatter.contentHash);
+      return;
+    }
+    log.warn(
+      `[${context}] removing hash for legacy memory ${memory.frontmatter.id ?? "(unknown)"} via content fallback - no contentHash in frontmatter`
+    );
+    index.remove(memory.content);
+  }
+  /**
+   * Issue #1671 — backfill bi-temporal bounds onto an existing promoted/deduped
+   * copy that was written BEFORE the source fact carried a resolved
+   * `invalid_at`/`observedAt`/`eventTimeSource`.
+   *
+   * On re-extraction/backfill, a fact may now carry a resolved end bound (e.g.
+   * "until June 2025") that the existing copy lacks because it was promoted
+   * before bi-temporal wiring existed. Without this backfill, recall keeps
+   * surfacing an expired fact even though the source copy now expires correctly.
+   *
+   * Finds the active fact in `targetStorage` matching `dedupContent`, then
+   * patches the temporal frontmatter the existing copy is missing. Best-effort
+   * / fail-open — any I/O error is logged and swallowed so the dedup
+   * short-circuit is never blocked by a backfill failure.
+   *
+   * Matching: the stored `frontmatter.contentHash` is compared against
+   * `ContentHashIndex.computeHash(dedupContent)` first (the exact hash the
+   * content-hash index uses), then falls back to stripping citations and
+   * comparing normalized bodies. This handles inline-attribution deployments
+   * where the persisted body carries a citation marker the dedup key does not.
+   *
+   * I/O gate: only triggers when `invalidAt` is present (the end bound that
+   * actually changes recall behavior by expiring the fact). `observedAt` and
+   * `eventTimeSource` alone don'\''t expire a fact, so backfilling them without
+   * an end bound would cause a full readAllMemories scan on every dedup hit
+   * under biTemporal for no recall benefit.
+   *
+   * Only patches fields the existing copy LACKS — never overwrites a bound the
+   * copy already carries.
+   */
+  async backfillTemporalBoundsOnDedupHit(targetStorage, dedupContent, bounds, entityRef) {
+    const hasExtractedStart = bounds.validFrom !== void 0 && bounds.eventTimeSource === "extracted";
+    if (!bounds.invalidAt && !hasExtractedStart) return;
+    try {
+      const incomingHash = ContentHashIndex.computeHash(dedupContent);
+      const normalizedIncoming = ContentHashIndex.normalizeContent(dedupContent);
+      const incomingEntityNorm = entityRef ? normalizeSupersessionKey(entityRef) : void 0;
+      const all = await targetStorage.readAllMemories();
+      const existing = all.find((m) => {
+        if (m.frontmatter.category !== "fact") return false;
+        if ((m.frontmatter.status ?? "active") !== "active") return false;
+        if (incomingEntityNorm && m.frontmatter.entityRef && normalizeSupersessionKey(m.frontmatter.entityRef) !== incomingEntityNorm) {
+          return false;
+        }
+        if (m.frontmatter.contentHash) {
+          return m.frontmatter.contentHash === incomingHash;
+        }
+        return ContentHashIndex.normalizeContent(
+          stripCitationForTemplate(m.content ?? "", this.deps.config.inlineSourceAttributionFormat)
+        ) === normalizedIncoming;
+      });
+      if (!existing) return;
+      const patch = {};
+      const fm = existing.frontmatter;
+      if (bounds.invalidAt && (!fm.invalid_at || fm.invalid_at.length === 0)) {
+        patch.invalid_at = bounds.invalidAt;
+      }
+      if (bounds.observedAt && (!fm.observedAt || fm.observedAt.length === 0)) {
+        patch.observedAt = bounds.observedAt;
+      }
+      if (bounds.eventTimeSource && (!fm.eventTimeSource || fm.eventTimeSource.length === 0)) {
+        patch.eventTimeSource = bounds.eventTimeSource;
+      }
+      if (bounds.validFrom && bounds.eventTimeSource === "extracted" && fm.valid_at !== bounds.validFrom) {
+        patch.valid_at = bounds.validFrom;
+        if (fm.eventTimeSource !== "extracted") {
+          patch.eventTimeSource = "extracted";
+        }
+      }
+      if (Object.keys(patch).length === 0) return;
+      const ok = await targetStorage.writeMemoryFrontmatter(existing, patch);
+      if (ok) {
+        log.debug(
+          `bitemporal-backfill: patched ${Object.keys(patch).join(",")} onto existing fact ${fm.id ?? "(unknown)"} in ${targetStorage.dir}`
+        );
+      }
+    } catch (err) {
+      log.warn(
+        `bitemporal-backfill: failed open for ${targetStorage.dir}: ${err}`
+      );
+    }
+  }
+  async saveContentHashIndexes() {
+    const indexes = /* @__PURE__ */ new Set();
+    if (this.deps.contentHashIndex) indexes.add(this.deps.contentHashIndex);
+    for (const index of this.deps.contentHashIndexesByStorageDir.values()) {
+      indexes.add(index);
+    }
+    for (const index of indexes) {
+      await index.save();
+    }
+  }
+  async indexPersistedMemory(storage, memoryId) {
+    if (!resolveMemoryLifecycleCapabilities(this.deps.config).embeddingFallback) return;
+    if (!await this.deps.embeddingFallback.isAvailable()) return;
+    const memory = await storage.getMemoryById(memoryId);
+    if (!memory) return;
+    await this.deps.embeddingFallback.indexFile(
+      memoryId,
+      memory.content,
+      memory.path
+    );
+  }
+  /**
+   * Build a graph edge for a persisted memory (v8.2).
+   * Shared helper used by both the chunked and non-chunked write paths to avoid duplication.
+   * Fail-open: caller wraps in try/catch.
+   */
+  async buildGraphEdge(storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps = resolveGraphConstructionCapabilities(this.deps.config)) {
+    const entitySiblings = [];
+    if (entityRef) {
+      try {
+        const allMems = allMemsForGraph ?? [];
+        for (const m of allMems) {
+          if (m.frontmatter.entityRef === entityRef) {
+            const rel = path12.relative(storage.dir, m.path);
+            if (rel !== memoryRelPath) entitySiblings.push(rel);
+          }
+        }
+      } catch {
+      }
+    }
+    const recentInThread = [];
+    if (threadIdForEdge && threadEpisodeIdsForGraph?.length) {
+      try {
+        recentInThread.push(
+          ...resolveRecentThreadMemoryPaths({
+            threadEpisodeIds: threadEpisodeIdsForGraph,
+            currentMemoryId: memoryId,
+            allMemsForGraph,
+            pathById: memoryPathById,
+            storageDir: storage.dir,
+            maxRecent: 3
+          })
+        );
+      } catch {
+      }
+    }
+    if (recentInThread.length === 0 && graphCaps.graphWriteSessionAdjacency && fallbackCausalPredecessor && fallbackCausalPredecessor !== memoryRelPath) {
+      recentInThread.push(fallbackCausalPredecessor);
+    }
+    const causalPredecessor = recentInThread[recentInThread.length - 1] ?? fallbackCausalPredecessor;
+    await this.deps.graphIndexFor(storage).onMemoryWritten({
+      memoryPath: memoryRelPath,
+      entityRef,
+      content: factContent,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      threadId: threadIdForEdge,
+      recentInThread,
+      entitySiblings,
+      causalPredecessor,
+      graphCapsOverride: {
+        entityGraph: graphCaps.entityGraph,
+        timeGraph: graphCaps.timeGraph,
+        causalGraph: graphCaps.causalGraph,
+        multiGraphMemory: graphCaps.multiGraphMemory
+      }
+    });
+  }
+  /**
+   * Batch-update temporal and tag indexes after extraction (v8.1).
+   * Reads each persisted memory's path + frontmatter and adds them to
+   * state/index_time.json and state/index_tags.json.
+   * Fail-open: any error is logged but does not abort extraction.
+   */
+  async updateTemporalTagIndexes(storage, persistedIds) {
+    const caps = resolveCapabilities(this.deps.config);
+    if (!resolveIndexingCapabilities(this.deps.config).queryAwareIndexing && !caps.parallelRetrieval)
+      return;
+    const needsFullRebuild = !indexesExist(this.deps.config.memoryDir);
+    if (!needsFullRebuild && persistedIds.length === 0) return;
+    try {
+      const allMemories = needsFullRebuild && resolveNamespaceCapabilities(this.deps.config).namespaces ? await this.deps.readAllMemoriesForNamespaces(
+        Array.from(
+          /* @__PURE__ */ new Set([
+            this.deps.config.defaultNamespace,
+            this.deps.config.sharedNamespace,
+            ...this.deps.config.namespacePolicies.map((p) => p.name)
+          ])
+        )
+      ) : await storage.readAllMemories();
+      const pool = needsFullRebuild ? allMemories.filter((m) => isActiveMemoryStatus(m.frontmatter.status)) : (() => {
+        const idSet = new Set(persistedIds);
+        return allMemories.filter((m) => idSet.has(m.frontmatter.id));
+      })();
+      const entries = [];
+      for (const mem of pool) {
+        if (mem.path && mem.frontmatter?.created) {
+          entries.push({
+            path: mem.path,
+            createdAt: mem.frontmatter.created,
+            tags: mem.frontmatter.tags ?? []
+          });
+        }
+      }
+      if (needsFullRebuild) {
+        clearIndexes(this.deps.config.memoryDir);
+        if (entries.length > 0) {
+          indexMemoriesBatch(this.deps.config.memoryDir, entries);
+        }
+        log.info(
+          `temporal-index: bootstrapped from ${entries.length} active memories`
+        );
+      } else if (entries.length > 0) {
+        indexMemoriesBatch(this.deps.config.memoryDir, entries);
+      }
+    } catch (err) {
+      log.debug(`temporal-index update failed (non-fatal): ${err}`);
+    }
+  }
+  /**
+   * Issue #373 — nearest-neighbor lookup for the write-time semantic dedup
+   * guard. Returns the top-K embedding hits against the currently indexed
+   * memories, or an empty array when the embedding backend is unavailable.
+   * Intentionally does NOT throw; `decideSemanticDedup` treats both "empty"
+   * and "error" outcomes as fail-open (keep the candidate).
+   *
+   * PR #399 P1 fix: when namespaces are enabled the lookup must be scoped
+   * to the SAME namespace as the fact being written. Otherwise a
+   * high-similarity memory from another namespace can suppress a write in
+   * the target namespace — cross-tenant data loss. Callers pass the target
+   * storage so we can translate its root directory into the correct index
+   * path prefix (and, for the legacy default-namespace layout at
+   * `memoryDir` root, an exclusion list for `namespaces/*`).
+   */
+  async semanticDedupLookup(content, limit, targetStorage) {
+    if (!resolveMemoryLifecycleCapabilities(this.deps.config).embeddingFallback) {
+      throw new Error("semantic dedup: embedding backend not configured");
+    }
+    if (!await this.deps.embeddingFallback.isAvailable()) {
+      log.debug("semantic dedup: embedding backend unavailable, skipping");
+      throw new Error("semantic dedup: embedding backend unavailable");
+    }
+    const scope = this.deps.semanticDedupScopeFor(targetStorage);
+    const hits = await this.deps.embeddingFallback.search(content, limit, { ...scope, throwOnTimeout: true });
+    if (!Array.isArray(hits) || hits.length === 0) return [];
+    return hits.map((hit) => ({
+      id: hit.id,
+      score: hit.score,
+      path: hit.path
+    }));
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -13533,7 +13805,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path12.join(os2.homedir(), ".openclaw", "workspace");
+  return path13.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -13894,7 +14166,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path12.relative(storageDir, mem.path));
+    pathById.set(id, path13.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -13902,7 +14174,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path12.join(options.storageDir, options.memoryRelPath),
+    path: path13.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -13922,16 +14194,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path12.join("corrections", `${options.memoryId}.md`);
+    return path13.join("corrections", `${options.memoryId}.md`);
   }
   const subtree = categoryDirName(options.category);
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path12.join(subtree, day, `${options.memoryId}.md`);
+    return path13.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path12.join(subtree, `${options.memoryId}.md`);
+  return path13.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -14492,7 +14764,7 @@ var Orchestrator = class _Orchestrator {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path12.resolve(storageDir);
+    const resolvedStorageDir = path13.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -14503,21 +14775,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path12.resolve(storageDir);
-    const resolvedMemoryDir = path12.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path13.resolve(storageDir);
+    const resolvedMemoryDir = path13.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path12.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path13.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path12.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path12.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path13.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path13.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path12.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path13.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path12.basename(resolvedStorageDir);
+    const leaf = path13.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -14545,7 +14817,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path12.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path13.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -14582,7 +14854,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path12.resolve(record.storageDir);
+      const resolvedStorageDir = path13.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -14730,123 +15002,40 @@ var Orchestrator = class _Orchestrator {
     return index;
   }
   async hasContentHashDedup(targetStorage, content) {
-    const index = await this.contentHashIndexForStorage(targetStorage);
-    return index ? index.has(content) : false;
+    return this.persistenceIndexCoordinator.hasContentHashDedup(
+      targetStorage,
+      content
+    );
   }
   async addContentHashDedup(targetStorage, content) {
-    const index = await this.contentHashIndexForStorage(targetStorage);
-    if (!index) return;
-    index.add(content);
+    return this.persistenceIndexCoordinator.addContentHashDedup(
+      targetStorage,
+      content
+    );
   }
   async removeContentHashForMemory(targetStorage, memory, context) {
-    const index = await this.contentHashIndexForStorage(targetStorage);
-    if (!index) return;
-    if (memory.frontmatter.contentHash) {
-      index.removeByHash(memory.frontmatter.contentHash);
-      return;
-    }
-    log.warn(
-      `[${context}] removing hash for legacy memory ${memory.frontmatter.id ?? "(unknown)"} via content fallback - no contentHash in frontmatter`
+    return this.persistenceIndexCoordinator.removeContentHashForMemory(
+      targetStorage,
+      memory,
+      context
     );
-    index.remove(memory.content);
   }
-  /**
-   * Issue #1671 — backfill bi-temporal bounds onto an existing promoted/deduped
-   * copy that was written BEFORE the source fact carried a resolved
-   * `invalid_at`/`observedAt`/`eventTimeSource`.
-   *
-   * On re-extraction/backfill, a fact may now carry a resolved end bound (e.g.
-   * "until June 2025") that the existing copy lacks because it was promoted
-   * before bi-temporal wiring existed. Without this backfill, recall keeps
-   * surfacing an expired fact even though the source copy now expires correctly.
-   *
-   * Finds the active fact in `targetStorage` matching `dedupContent`, then
-   * patches the temporal frontmatter the existing copy is missing. Best-effort
-   * / fail-open — any I/O error is logged and swallowed so the dedup
-   * short-circuit is never blocked by a backfill failure.
-   *
-   * Matching: the stored `frontmatter.contentHash` is compared against
-   * `ContentHashIndex.computeHash(dedupContent)` first (the exact hash the
-   * content-hash index uses), then falls back to stripping citations and
-   * comparing normalized bodies. This handles inline-attribution deployments
-   * where the persisted body carries a citation marker the dedup key does not.
-   *
-   * I/O gate: only triggers when `invalidAt` is present (the end bound that
-   * actually changes recall behavior by expiring the fact). `observedAt` and
-   * `eventTimeSource` alone don'\''t expire a fact, so backfilling them without
-   * an end bound would cause a full readAllMemories scan on every dedup hit
-   * under biTemporal for no recall benefit.
-   *
-   * Only patches fields the existing copy LACKS — never overwrites a bound the
-   * copy already carries.
-   */
   async backfillTemporalBoundsOnDedupHit(targetStorage, dedupContent, bounds, entityRef) {
-    const hasExtractedStart = bounds.validFrom !== void 0 && bounds.eventTimeSource === "extracted";
-    if (!bounds.invalidAt && !hasExtractedStart) return;
-    try {
-      const incomingHash = ContentHashIndex.computeHash(dedupContent);
-      const normalizedIncoming = ContentHashIndex.normalizeContent(dedupContent);
-      const incomingEntityNorm = entityRef ? normalizeSupersessionKey(entityRef) : void 0;
-      const all = await targetStorage.readAllMemories();
-      const existing = all.find((m) => {
-        if (m.frontmatter.category !== "fact") return false;
-        if ((m.frontmatter.status ?? "active") !== "active") return false;
-        if (incomingEntityNorm && m.frontmatter.entityRef && normalizeSupersessionKey(m.frontmatter.entityRef) !== incomingEntityNorm) {
-          return false;
-        }
-        if (m.frontmatter.contentHash) {
-          return m.frontmatter.contentHash === incomingHash;
-        }
-        return ContentHashIndex.normalizeContent(
-          stripCitationForTemplate(m.content ?? "", this.config.inlineSourceAttributionFormat)
-        ) === normalizedIncoming;
-      });
-      if (!existing) return;
-      const patch = {};
-      const fm = existing.frontmatter;
-      if (bounds.invalidAt && (!fm.invalid_at || fm.invalid_at.length === 0)) {
-        patch.invalid_at = bounds.invalidAt;
-      }
-      if (bounds.observedAt && (!fm.observedAt || fm.observedAt.length === 0)) {
-        patch.observedAt = bounds.observedAt;
-      }
-      if (bounds.eventTimeSource && (!fm.eventTimeSource || fm.eventTimeSource.length === 0)) {
-        patch.eventTimeSource = bounds.eventTimeSource;
-      }
-      if (bounds.validFrom && bounds.eventTimeSource === "extracted" && fm.valid_at !== bounds.validFrom) {
-        patch.valid_at = bounds.validFrom;
-        if (fm.eventTimeSource !== "extracted") {
-          patch.eventTimeSource = "extracted";
-        }
-      }
-      if (Object.keys(patch).length === 0) return;
-      const ok = await targetStorage.writeMemoryFrontmatter(existing, patch);
-      if (ok) {
-        log.debug(
-          `bitemporal-backfill: patched ${Object.keys(patch).join(",")} onto existing fact ${fm.id ?? "(unknown)"} in ${targetStorage.dir}`
-        );
-      }
-    } catch (err) {
-      log.warn(
-        `bitemporal-backfill: failed open for ${targetStorage.dir}: ${err}`
-      );
-    }
+    return this.persistenceIndexCoordinator.backfillTemporalBoundsOnDedupHit(
+      targetStorage,
+      dedupContent,
+      bounds,
+      entityRef
+    );
   }
   async saveContentHashIndexes() {
-    const indexes = /* @__PURE__ */ new Set();
-    if (this.contentHashIndex) indexes.add(this.contentHashIndex);
-    for (const index of this.contentHashIndexesByStorageDir.values()) {
-      indexes.add(index);
-    }
-    for (const index of indexes) {
-      await index.save();
-    }
+    return this.persistenceIndexCoordinator.saveContentHashIndexes();
   }
   constructor(config) {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path12.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path13.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -14916,7 +15105,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = resolveConsolidationCapabilities(config).compounding ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path12.join(
+    this.conversationIndexDir = path13.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -15052,7 +15241,7 @@ var Orchestrator = class _Orchestrator {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path12.join(config.memoryDir, "threads"),
+      path13.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -15467,15 +15656,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path12.isAbsolute(rel) ? rel : path12.join(this.config.workspaceDir, rel);
+        const abs = path13.isAbsolute(rel) ? rel : path13.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile5(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path12.join(
+            const archiveDir = path13.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path12.basename(abs);
+            const base = path13.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -15500,8 +15689,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path12.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path12.dirname(fp), { recursive: true });
+        const fp = path13.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path13.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -15640,7 +15829,7 @@ ${doc.content}` : doc.content,
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path12.join(storage.dir, categoryDir, date);
+        const dateDir = path13.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -15649,7 +15838,7 @@ ${doc.content}` : doc.content,
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path12.join(dateDir, entry.name);
+            const fullPath = path13.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile5(fullPath, "utf-8");
@@ -15671,7 +15860,7 @@ ${doc.content}` : doc.content,
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path12.basename(entry.name, ".md"),
+                  id: fm.id || path13.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -15694,13 +15883,13 @@ ${doc.content}` : doc.content,
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path12.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path13.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir3(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path12.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path13.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile5(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -16175,12 +16364,12 @@ ${doc.content}` : doc.content,
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path12.join(this.config.memoryDir, "state");
+      return path13.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path12.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path13.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path12.join(
+    const candidate = path13.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -16188,11 +16377,11 @@ ${doc.content}` : doc.content,
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path12.join(candidate, "state");
+        return path13.join(candidate, "state");
       }
     } catch {
     }
-    return path12.join(this.config.memoryDir, "state");
+    return path13.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -16689,6 +16878,36 @@ ${doc.content}` : doc.content,
     }
     return this._orchestratorInitCoordinator;
   }
+  /**
+   * Persistence-index coordinator (issue #1526 seam 23). Owns post-persist
+   * bookkeeping (content-hash dedup, temporal indexes, graph edges,
+   * semantic dedup lookup). Lazy + accessor-wired (late-binding rule).
+   */
+  _persistenceIndexCoordinator;
+  get persistenceIndexCoordinator() {
+    if (!this._persistenceIndexCoordinator) {
+      const self = this;
+      this._persistenceIndexCoordinator = new PersistenceIndexCoordinator({
+        get config() {
+          return self.config;
+        },
+        get contentHashIndex() {
+          return self.contentHashIndex;
+        },
+        contentHashIndexForStorage: (targetStorage) => self.contentHashIndexForStorage(targetStorage),
+        get contentHashIndexesByStorageDir() {
+          return self.contentHashIndexesByStorageDir;
+        },
+        get embeddingFallback() {
+          return self.embeddingFallback;
+        },
+        graphIndexFor: (storage) => self.graphIndexFor(storage),
+        readAllMemoriesForNamespaces: (namespaces) => self.readAllMemoriesForNamespaces(namespaces),
+        semanticDedupScopeFor: (targetStorage) => self.semanticDedupScopeFor(targetStorage)
+      });
+    }
+    return this._persistenceIndexCoordinator;
+  }
   async recallInternal(prompt, sessionKey, options = {}, caps = resolveCapabilities(this.config), graphCaps = resolveGraphConstructionCapabilities(this.config), lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config)) {
     return this.recallInternalCoordinator.recallInternal(
       prompt,
@@ -16949,71 +17168,25 @@ ${doc.content}` : doc.content,
     }
   }
   async indexPersistedMemory(storage, memoryId) {
-    if (!resolveMemoryLifecycleCapabilities(this.config).embeddingFallback) return;
-    if (!await this.embeddingFallback.isAvailable()) return;
-    const memory = await storage.getMemoryById(memoryId);
-    if (!memory) return;
-    await this.embeddingFallback.indexFile(
-      memoryId,
-      memory.content,
-      memory.path
+    return this.persistenceIndexCoordinator.indexPersistedMemory(
+      storage,
+      memoryId
     );
   }
-  /**
-   * Build a graph edge for a persisted memory (v8.2).
-   * Shared helper used by both the chunked and non-chunked write paths to avoid duplication.
-   * Fail-open: caller wraps in try/catch.
-   */
   async buildGraphEdge(storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps = resolveGraphConstructionCapabilities(this.config)) {
-    const entitySiblings = [];
-    if (entityRef) {
-      try {
-        const allMems = allMemsForGraph ?? [];
-        for (const m of allMems) {
-          if (m.frontmatter.entityRef === entityRef) {
-            const rel = path12.relative(storage.dir, m.path);
-            if (rel !== memoryRelPath) entitySiblings.push(rel);
-          }
-        }
-      } catch {
-      }
-    }
-    const recentInThread = [];
-    if (threadIdForEdge && threadEpisodeIdsForGraph?.length) {
-      try {
-        recentInThread.push(
-          ...resolveRecentThreadMemoryPaths({
-            threadEpisodeIds: threadEpisodeIdsForGraph,
-            currentMemoryId: memoryId,
-            allMemsForGraph,
-            pathById: memoryPathById,
-            storageDir: storage.dir,
-            maxRecent: 3
-          })
-        );
-      } catch {
-      }
-    }
-    if (recentInThread.length === 0 && graphCaps.graphWriteSessionAdjacency && fallbackCausalPredecessor && fallbackCausalPredecessor !== memoryRelPath) {
-      recentInThread.push(fallbackCausalPredecessor);
-    }
-    const causalPredecessor = recentInThread[recentInThread.length - 1] ?? fallbackCausalPredecessor;
-    await this.graphIndexFor(storage).onMemoryWritten({
-      memoryPath: memoryRelPath,
+    return this.persistenceIndexCoordinator.buildGraphEdge(
+      storage,
+      memoryRelPath,
       entityRef,
-      content: factContent,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      threadId: threadIdForEdge,
-      recentInThread,
-      entitySiblings,
-      causalPredecessor,
-      graphCapsOverride: {
-        entityGraph: graphCaps.entityGraph,
-        timeGraph: graphCaps.timeGraph,
-        causalGraph: graphCaps.causalGraph,
-        multiGraphMemory: graphCaps.multiGraphMemory
-      }
-    });
+      memoryId,
+      factContent,
+      allMemsForGraph,
+      memoryPathById,
+      threadIdForEdge,
+      threadEpisodeIdsForGraph,
+      fallbackCausalPredecessor,
+      graphCaps
+    );
   }
   graphIndexFor(storage) {
     const key = storage.dir;
@@ -17023,56 +17196,11 @@ ${doc.content}` : doc.content,
     this.graphIndexes.set(key, created);
     return created;
   }
-  /**
-   * Batch-update temporal and tag indexes after extraction (v8.1).
-   * Reads each persisted memory's path + frontmatter and adds them to
-   * state/index_time.json and state/index_tags.json.
-   * Fail-open: any error is logged but does not abort extraction.
-   */
   async updateTemporalTagIndexes(storage, persistedIds) {
-    const caps = resolveCapabilities(this.config);
-    if (!resolveIndexingCapabilities(this.config).queryAwareIndexing && !caps.parallelRetrieval)
-      return;
-    const needsFullRebuild = !indexesExist(this.config.memoryDir);
-    if (!needsFullRebuild && persistedIds.length === 0) return;
-    try {
-      const allMemories = needsFullRebuild && resolveNamespaceCapabilities(this.config).namespaces ? await this.readAllMemoriesForNamespaces(
-        Array.from(
-          /* @__PURE__ */ new Set([
-            this.config.defaultNamespace,
-            this.config.sharedNamespace,
-            ...this.config.namespacePolicies.map((p) => p.name)
-          ])
-        )
-      ) : await storage.readAllMemories();
-      const pool = needsFullRebuild ? allMemories.filter((m) => isActiveMemoryStatus(m.frontmatter.status)) : (() => {
-        const idSet = new Set(persistedIds);
-        return allMemories.filter((m) => idSet.has(m.frontmatter.id));
-      })();
-      const entries = [];
-      for (const mem of pool) {
-        if (mem.path && mem.frontmatter?.created) {
-          entries.push({
-            path: mem.path,
-            createdAt: mem.frontmatter.created,
-            tags: mem.frontmatter.tags ?? []
-          });
-        }
-      }
-      if (needsFullRebuild) {
-        clearIndexes(this.config.memoryDir);
-        if (entries.length > 0) {
-          indexMemoriesBatch(this.config.memoryDir, entries);
-        }
-        log.info(
-          `temporal-index: bootstrapped from ${entries.length} active memories`
-        );
-      } else if (entries.length > 0) {
-        indexMemoriesBatch(this.config.memoryDir, entries);
-      }
-    } catch (err) {
-      log.debug(`temporal-index update failed (non-fatal): ${err}`);
-    }
+    return this.persistenceIndexCoordinator.updateTemporalTagIndexes(
+      storage,
+      persistedIds
+    );
   }
   /** IDs of facts persisted in the last extraction */
   lastPersistedIds = [];
@@ -17286,37 +17414,12 @@ ${reflectionsContent.trim()}
       recallSource
     );
   }
-  /**
-   * Issue #373 — nearest-neighbor lookup for the write-time semantic dedup
-   * guard. Returns the top-K embedding hits against the currently indexed
-   * memories, or an empty array when the embedding backend is unavailable.
-   * Intentionally does NOT throw; `decideSemanticDedup` treats both "empty"
-   * and "error" outcomes as fail-open (keep the candidate).
-   *
-   * PR #399 P1 fix: when namespaces are enabled the lookup must be scoped
-   * to the SAME namespace as the fact being written. Otherwise a
-   * high-similarity memory from another namespace can suppress a write in
-   * the target namespace — cross-tenant data loss. Callers pass the target
-   * storage so we can translate its root directory into the correct index
-   * path prefix (and, for the legacy default-namespace layout at
-   * `memoryDir` root, an exclusion list for `namespaces/*`).
-   */
   async semanticDedupLookup(content, limit, targetStorage) {
-    if (!resolveMemoryLifecycleCapabilities(this.config).embeddingFallback) {
-      throw new Error("semantic dedup: embedding backend not configured");
-    }
-    if (!await this.embeddingFallback.isAvailable()) {
-      log.debug("semantic dedup: embedding backend unavailable, skipping");
-      throw new Error("semantic dedup: embedding backend unavailable");
-    }
-    const scope = this.semanticDedupScopeFor(targetStorage);
-    const hits = await this.embeddingFallback.search(content, limit, { ...scope, throwOnTimeout: true });
-    if (!Array.isArray(hits) || hits.length === 0) return [];
-    return hits.map((hit) => ({
-      id: hit.id,
-      score: hit.score,
-      path: hit.path
-    }));
+    return this.persistenceIndexCoordinator.semanticDedupLookup(
+      content,
+      limit,
+      targetStorage
+    );
   }
   /**
    * Resolve the namespace-scoped filter to pass into
@@ -17334,12 +17437,12 @@ ${reflectionsContent.trim()}
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path12.resolve(this.config.memoryDir);
-    const storageDir = path12.resolve(targetStorage.dir);
+    const memoryDir = path13.resolve(this.config.memoryDir);
+    const storageDir = path13.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path12.relative(memoryDir, storageDir);
+    let rel = path13.relative(memoryDir, storageDir);
     if (!rel || rel.startsWith("..")) {
       log.debug(
         `semantic dedup: target storage dir ${storageDir} is outside memoryDir ${memoryDir}; scoping lookup to absolute path prefix`
@@ -18084,9 +18187,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path27 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path28 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
   const kind = typeof rec.kind === "string" && rec.kind.length > 0 ? rec.kind : void 0;
-  const item = path27 !== void 0 && kind !== void 0 ? { symbol, path: path27, kind } : path27 !== void 0 ? { symbol, path: path27 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path28 !== void 0 && kind !== void 0 ? { symbol, path: path28, kind } : path28 !== void 0 ? { symbol, path: path28 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -18160,7 +18263,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -18168,19 +18271,19 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path13.resolve(basePath);
+    this.basePath = path14.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path13.isAbsolute(remotePath) ? path13.resolve(remotePath) : path13.resolve(this.basePath, remotePath);
-    const relative = path13.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path13.sep}`) || path13.isAbsolute(relative)) {
+    const resolved = path14.isAbsolute(remotePath) ? path14.resolve(remotePath) : path14.resolve(this.basePath, remotePath);
+    const relative = path14.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path14.sep}`) || path14.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path13.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path13.sep}`) && !path13.isAbsolute(relative);
+    const relative = path14.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -18209,13 +18312,13 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path13.dirname(dest);
-    const relativeDir = path13.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path13.sep);
+    const destDir = path14.dirname(dest);
+    const relativeDir = path14.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path14.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path13.join(current, segment);
+      current = path14.join(current, segment);
       try {
         const stat5 = await fsp.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -18243,13 +18346,13 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path13.dirname(dest);
-    const relativeDir = path13.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path13.sep);
+    const destDir = path14.dirname(dest);
+    const relativeDir = path14.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path14.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path13.join(current, segment);
+      current = path14.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp.lstat(current);
@@ -18297,7 +18400,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path13.isAbsolute(remotePath)) {
+    if (path14.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -18370,7 +18473,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -18395,8 +18498,8 @@ async function scanForBinaries(memoryDir, config, manifest) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path14.join(dir, entry.name);
-      const relativePath = path14.relative(memoryDir, fullPath).split(path14.sep).join("/");
+      const fullPath = path15.join(dir, entry.name);
+      const relativePath = path15.relative(memoryDir, fullPath).split(path15.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -18436,15 +18539,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path15.join(memoryDir, MANIFEST_DIR);
+  return path16.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path15.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path16.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -18496,7 +18599,7 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import crypto3 from "crypto";
 async function hashFile2(filePath) {
   const content = await fsp4.readFile(filePath);
@@ -18519,13 +18622,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path16.isAbsolute(originalPath) || path16.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path17.isAbsolute(originalPath) || path17.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path16.resolve(memoryDir);
-  const fullPath = path16.resolve(memoryRoot, originalPath);
-  const relative = path16.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative)) {
+  const memoryRoot = path17.resolve(memoryDir);
+  const fullPath = path17.resolve(memoryRoot, originalPath);
+  const relative = path17.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -18536,7 +18639,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path16.sep).join("/");
+  const normalized = relPath.split(path17.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -18549,11 +18652,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path16.join(memoryDir, relPath);
+    const fullPath = path17.join(memoryDir, relPath);
     try {
       const stat5 = await fsp4.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path16.extname(relPath);
+      const ext = path17.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -18753,10 +18856,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path16.dirname(mdPath);
+  const mdDir = path17.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path16.sep).join("/");
+    const normalized = candidate.split(path17.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -18764,10 +18867,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path16.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path16.sep).join("/");
-  const originalAsFileRelative = path16.resolve(mdDir, ...originalPath.split("/"));
-  if (path16.resolve(originalAsFileRelative) === path16.resolve(assetAbsolute)) {
+  addCandidate(path17.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path17.sep).join("/");
+  const originalAsFileRelative = path17.resolve(mdDir, ...originalPath.split("/"));
+  if (path17.resolve(originalAsFileRelative) === path17.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -18863,7 +18966,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path16.join(current, entry.name);
+      const full = path17.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -18938,7 +19041,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path17 from "path";
+import path18 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -18953,8 +19056,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path17.resolve(memoryDir);
-  const resolvedOutputDir = path17.resolve(outputDir);
+  const resolvedMemoryDir = path18.resolve(memoryDir);
+  const resolvedOutputDir = path18.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -18992,7 +19095,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path17.join(memoryDir, "entities");
+    const entitiesDir = path18.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -19004,7 +19107,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path17.basename(filePath, ".md");
+        const fileName = path18.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -19016,7 +19119,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path17.join(memoryDir, "questions");
+    const questionsDir = path18.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -19057,8 +19160,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path17.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path17.isAbsolute(relative);
+  const relative = path18.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path18.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -19095,12 +19198,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path17.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path17.isAbsolute(relative)) {
+  const relative = path18.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path18.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path17.sep).filter(Boolean)) {
-    current = path17.join(current, segment);
+  for (const segment of relative.split(path18.sep).filter(Boolean)) {
+    current = path18.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -19130,17 +19233,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path17.resolve(outputRoot, ...segments);
-  const relative = path17.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path17.isAbsolute(relative)) {
+  const resolved = path18.resolve(outputRoot, ...segments);
+  const relative = path18.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path18.isAbsolute(relative)) {
     return resolved;
   }
   throw new Error(`context tree output path escapes outputDir: ${segments.join("/")}`);
 }
 function writeProjectedContent(realOutputDir, outputPath, generatedContent) {
   assertSafeOutputTarget(realOutputDir, outputPath);
-  fs.mkdirSync(path17.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path17.dirname(outputPath));
+  fs.mkdirSync(path18.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path18.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -19179,7 +19282,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path17.join(directory, entry.name);
+      const fullPath = path18.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -19232,13 +19335,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path17.basename(filePath, ".md");
-  const dateDir = path17.basename(path17.dirname(filePath));
+  const fileName = path18.basename(filePath, ".md");
+  const dateDir = path18.basename(path18.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path17.join(category, dateDir, `${fileName}.md`);
+    relPath = path18.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path17.join(category, `${fileName}.md`);
+    relPath = path18.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -19284,7 +19387,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path17.join("entities", `${fileName}.md`),
+    path: path18.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -19337,7 +19440,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path18 from "path";
+import path19 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -19439,7 +19542,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path18.resolve(options.directory ?? process.cwd());
+  const directory = path19.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -19481,7 +19584,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path18.join(dir, entry.name);
+      const fullPath = path19.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -19496,11 +19599,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path18.extname(f).toLowerCase();
+    const ext = path19.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path18.dirname(f) === root).map((f) => path18.basename(f))
+    files.filter((f) => path19.dirname(f) === root).map((f) => path19.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -19544,7 +19647,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path18.dirname(f) === root).map((f) => path18.basename(f))
+    files.filter((f) => path19.dirname(f) === root).map((f) => path19.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -19555,7 +19658,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path18.join(root, "package.json"));
+    const pkg = readJsonSafe(path19.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -19569,13 +19672,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path18.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path19.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path18.join(root, "package.json"));
+    const pkg = readJsonSafe(path19.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -19609,8 +19712,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path18.basename(filePath).toLowerCase();
-    const relPath = path18.relative(root, filePath);
+    const basename = path19.basename(filePath).toLowerCase();
+    const relPath = path19.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -19622,7 +19725,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path18.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path19.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -19643,7 +19746,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path18.sep);
+  const parts = relPath.split(path19.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -19687,7 +19790,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path19 from "path";
+import path20 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -19778,12 +19881,12 @@ function resolveTargets(targetPath) {
   const extensions = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
   function walk(dir) {
     for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = path19.join(dir, entry.name);
+      const fullPath = path20.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path19.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path20.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -19792,12 +19895,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path19.resolve(targetPath);
+  const resolvedTarget = path20.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path19.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path20.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path19.relative(projectRoot, path19.resolve(filePath)) || path19.basename(filePath);
+  const relativePath = path20.relative(projectRoot, path20.resolve(filePath)) || path20.basename(filePath);
   const statements = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paragraphs = content.split(/\n{2,}/).map((p) => p.trim()).filter((p) => p.length > 20 && p.length < 2e3);
@@ -19891,7 +19994,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path19.join(memoryDir, dir);
+    const fullDir = path20.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -19913,10 +20016,10 @@ function writeStatement(stmt, memoryDir) {
   const now = /* @__PURE__ */ new Date();
   const dateDir = now.toISOString().split("T")[0];
   const categoryDir = getCategoryDir(memoryDir, stmt.category);
-  const dir = path19.join(categoryDir, dateDir);
+  const dir = path20.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path19.join(dir, fileName);
+  const filePath = path20.join(dir, fileName);
   const frontmatter = [
     "---",
     `id: ${stmt.id}`,
@@ -19983,7 +20086,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path19.join(dir, entry.name);
+    const fullPath = path20.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -19994,7 +20097,7 @@ function walkFiles(dir, callback) {
 
 // src/dedup/index.ts
 import fs4 from "fs";
-import path20 from "path";
+import path21 from "path";
 import crypto5 from "crypto";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_LOAD = 1e4;
@@ -20136,7 +20239,7 @@ function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   const memoryRootReal = fs4.realpathSync(memoryDir);
   for (const category of allCategories) {
     if (result.length >= maxLoad) break;
-    const dir = path20.join(memoryDir, category);
+    const dir = path21.join(memoryDir, category);
     if (!fs4.existsSync(dir)) continue;
     const categoryStat = fs4.lstatSync(dir);
     if (categoryStat.isSymbolicLink()) {
@@ -20197,15 +20300,15 @@ function extractBody3(content) {
   return match ? match[1].trim() : content.trim();
 }
 function assertPathInsideRoot2(rootReal, targetReal, sourcePath) {
-  const rel = path20.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path20.isAbsolute(rel)) {
+  const rel = path21.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path21.isAbsolute(rel)) {
     return;
   }
   throw new Error(`Refusing to scan memory path outside root: ${sourcePath}`);
 }
 function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
   for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path20.join(dir, entry.name);
+    const fullPath = path21.join(dir, entry.name);
     const entryStat = fs4.lstatSync(fullPath);
     if (entryStat.isSymbolicLink()) {
       throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
@@ -20223,7 +20326,7 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 
 // src/review/index.ts
 import fs5 from "fs";
-import path21 from "path";
+import path22 from "path";
 var DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
 function realMemoryRoot(memoryDir) {
   try {
@@ -20235,8 +20338,8 @@ function realMemoryRoot(memoryDir) {
   }
 }
 function isPathInside2(rootReal, candidateReal) {
-  const relative = path21.relative(rootReal, candidateReal);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path21.isAbsolute(relative);
+  const relative = path22.relative(rootReal, candidateReal);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path22.isAbsolute(relative);
 }
 function isSafeDirectory(rootReal, dir) {
   try {
@@ -20279,7 +20382,7 @@ function listReviewItems(options) {
     if (filterReason && item.reviewReason !== filterReason) return;
     items.push(item);
   };
-  const suggestionsDir = path21.join(memoryDir, "suggestions");
+  const suggestionsDir = path22.join(memoryDir, "suggestions");
   if (!isLimitReached() && fs5.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
     walkMd(rootReal, suggestionsDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -20300,7 +20403,7 @@ function listReviewItems(options) {
       return isLimitReached();
     });
   }
-  const reviewDir = path21.join(memoryDir, "review");
+  const reviewDir = path22.join(memoryDir, "review");
   if (!isLimitReached() && fs5.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
     walkMd(rootReal, reviewDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -20325,7 +20428,7 @@ function listReviewItems(options) {
   const categories = ALL_CATEGORY_DIRS;
   for (const category of categories) {
     if (isLimitReached()) break;
-    const dir = path21.join(memoryDir, category);
+    const dir = path22.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     walkMd(rootReal, dir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -20410,8 +20513,8 @@ function approveItem(memoryDir, itemId, options) {
   const targetDir = getCategoryDir(memoryDir, category);
   const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   ensureSafeDirectory(rootReal, targetDir);
-  const outputPath = path21.join(targetDir, dateDir, path21.basename(found.filePath));
-  ensureSafeDirectory(rootReal, path21.dirname(outputPath));
+  const outputPath = path22.join(targetDir, dateDir, path22.basename(found.filePath));
+  ensureSafeDirectory(rootReal, path22.dirname(outputPath));
   const promotedPath = writeFileWithoutClobber(outputPath, updatedContent, itemId);
   fs5.unlinkSync(found.filePath);
   return {
@@ -20469,13 +20572,13 @@ function findReviewFileById(memoryDir, id, options = {}) {
   const rootReal = realMemoryRoot(memoryDir);
   if (!rootReal) return null;
   for (const loc of ["suggestions", "review"]) {
-    const dir = path21.join(memoryDir, loc);
+    const dir = path22.join(memoryDir, loc);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id);
     if (found) return { filePath: found, location: "queue" };
   }
   for (const category of ALL_CATEGORY_DIRS) {
-    const dir = path21.join(memoryDir, category);
+    const dir = path22.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id, (fm) => isLowConfidenceReviewCandidate(fm, options));
     if (found) return { filePath: found, location: "category" };
@@ -20551,10 +20654,10 @@ function readFileSafe3(filePath) {
   }
 }
 function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path21.parse(basePath);
+  const parsed = path22.parse(basePath);
   const safeDiscriminator = sanitizeFilePart(discriminator);
   for (let attempt = 0; attempt < 1e3; attempt++) {
-    const candidate = attempt === 0 ? basePath : path21.join(
+    const candidate = attempt === 0 ? basePath : path22.join(
       parsed.dir,
       `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
     );
@@ -20610,7 +20713,7 @@ function extractBody4(content) {
 function walkMd(rootReal, dir, callback) {
   if (!isSafeDirectory(rootReal, dir)) return false;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path21.join(dir, entry.name);
+    const fullPath = path22.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       if (walkMd(rootReal, fullPath, callback)) return true;
@@ -20625,7 +20728,7 @@ function walkMdPaths(rootReal, dir) {
   const results = [];
   if (!isSafeDirectory(rootReal, dir)) return results;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path21.join(dir, entry.name);
+    const fullPath = path22.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       results.push(...walkMdPaths(rootReal, fullPath));
@@ -20638,7 +20741,7 @@ function walkMdPaths(rootReal, dir) {
 
 // src/sync/index.ts
 import fs6 from "fs";
-import path22 from "path";
+import path23 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -20660,7 +20763,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path22.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path23.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -20676,7 +20779,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs6.mkdirSync(path22.dirname(stateFilePath), { recursive: true });
+    fs6.mkdirSync(path23.dirname(stateFilePath), { recursive: true });
     fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -20742,13 +20845,13 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path22.join(dir, entry.name);
+      const fullPath = path23.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path22.extname(entry.name).toLowerCase();
+        const ext = path23.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path22.relative(root, fullPath);
+        const relPath = path23.relative(root, fullPath);
         try {
           const content = fs6.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -20763,7 +20866,7 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path22.join(sourceDir, relPath);
+    const fullPath = path23.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -20796,7 +20899,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path22.join(sourceDir, relPath),
+        filePath: path23.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -20826,20 +20929,20 @@ function hashContent3(content) {
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs7 from "fs";
-import path23 from "path";
+import path24 from "path";
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
 var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
-  return path23.resolve(memoryDir);
+  return path24.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path23.join(homeDir, ".config", "engram", "spaces");
+  return path24.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path23.join(getSpacesDir(baseDir), "manifest.json");
+  return path24.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs7.existsSync(getManifestPath(baseDir))) {
@@ -20886,9 +20989,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path23.dirname(manifestPath2);
+  const manifestDir2 = path24.dirname(manifestPath2);
   fs7.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path23.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const tempPath = path24.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
     fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -20903,7 +21006,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs7.mkdirSync(path23.dirname(lockDir), { recursive: true });
+  fs7.mkdirSync(path24.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -20929,7 +21032,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs7.mkdirSync(lockDir, { recursive: false });
       try {
-        fs7.writeFileSync(path23.join(lockDir, "owner"), `${owner}
+        fs7.writeFileSync(path24.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs7.rmSync(lockDir, { recursive: true, force: true });
@@ -20959,7 +21062,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path23.join(lockDir, "owner");
+    const ownerPath = path24.join(lockDir, "owner");
     if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs7.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -20975,7 +21078,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs7.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs7.writeFileSync(path23.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs7.writeFileSync(path24.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs7.rmSync(reclaimDir, { recursive: true, force: true });
@@ -21050,7 +21153,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs7.readFileSync(path23.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs7.readFileSync(path24.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -21122,8 +21225,8 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path23.join(homeDir, ".engram", "memory");
-  const openclawPath = path23.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const standalonePath = path24.join(homeDir, ".engram", "memory");
+  const openclawPath = path24.join(homeDir, ".openclaw", "workspace", "memory", "local");
   const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs7.existsSync(standalonePath) ? standalonePath : fs7.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -21152,7 +21255,7 @@ function createSpace(options) {
   const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const memoryDir = normalizeSpaceMemoryDir(
-    options.memoryDir ?? path23.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path24.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -21373,14 +21476,14 @@ function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path23.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path24.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs7.existsSync(auditPath)) return [];
   const lines = fs7.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path23.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs7.mkdirSync(path23.dirname(auditPath), { recursive: true });
+  const auditPath = path24.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs7.mkdirSync(path24.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -21412,8 +21515,8 @@ function copyMemories(sourceDir, targetDir, options) {
       continue;
     }
     const content = fs7.readFileSync(sourcePath, "utf8");
-    const relativePath = path23.relative(sourceRoot, sourceRealPath);
-    const targetPath = path23.resolve(targetRoot, relativePath);
+    const relativePath = path24.relative(sourceRoot, sourceRealPath);
+    const targetPath = path24.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
@@ -21455,8 +21558,8 @@ function copyMemories(sourceDir, targetDir, options) {
       skipped++;
       continue;
     }
-    fs7.mkdirSync(path23.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path23.dirname(targetPath));
+    fs7.mkdirSync(path24.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path24.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
@@ -21473,7 +21576,7 @@ function walkMd2(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path23.join(d, entry.name);
+      const fullPath = path24.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -21502,8 +21605,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path23.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path23.isAbsolute(relative);
+  const relative = path24.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -21624,7 +21727,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs8 from "fs";
 import os3 from "os";
-import path24 from "path";
+import path25 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -21633,12 +21736,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path24.join(homeDir, input.slice(2));
+    return path25.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path24.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path25.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -21652,12 +21755,12 @@ var CodexMemoryExtensionPublisher = class {
   async resolveExtensionRoot(env) {
     const homeDir = resolveEnvHome(env);
     const codexHomeInput = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() : env.CODEX_HOME?.trim();
-    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path24.resolve(homeDir, ".codex");
-    return path24.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path25.resolve(homeDir, ".codex");
+    return path25.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path24.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path25.join(resolveHomeDir(), ".codex");
       return fs8.existsSync(home);
     } catch {
       return false;
@@ -21708,7 +21811,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path24.join(extensionRoot, "instructions.md");
+    const instructionsPath = path25.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -21828,7 +21931,7 @@ function publisherForConnector(connectorId) {
 // src/session-summaries/index.ts
 import { createHash as createHash8 } from "crypto";
 import { lstat as lstat2, mkdir as mkdir7, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -22333,7 +22436,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path25.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path26.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -22343,13 +22446,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path25.join(dir, entry.name);
+      const fullPath = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path25.extname(entry.name).toLowerCase();
+      const ext = path26.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -22376,7 +22479,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path25.resolve(expandTildePath(inputDir.trim()));
+  return path26.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -22533,11 +22636,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path25.extname(filePath).toLowerCase();
+    const fileExtension = path26.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path25.basename(filePath),
+        fileName: path26.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -22593,7 +22696,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile6(path25.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile6(path26.resolve(expandTildePath(pathLike)), "utf-8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("redaction config must be a JSON object");
@@ -22606,15 +22709,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path25.join(
-    path25.resolve(expandTildePath(memoryDir)),
+  return path26.join(
+    path26.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path25.dirname(filePath), { recursive: true });
+  await mkdir7(path26.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -22632,7 +22735,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path25.resolve(expandTildePath(options.output));
+    const outputPath = path26.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -22667,19 +22770,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat3, mkdir as mkdir8, readFile as readFile7, realpath as realpath2, writeFile as writeFile8 } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path26.resolve(opts.targetRoot);
+  const rootAbs = path27.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path26.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path27.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path26.resolve(opts.sourceArchive);
+  const archiveAbs = path27.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -22701,10 +22804,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path26.join(forkDirAbs, "lineage.json");
+  const lineagePath = path27.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath2(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path26.dirname(lineagePath), { recursive: true });
+  await mkdir8(path27.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -22718,11 +22821,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path26.resolve(targetRoot);
+  const rootAbs = path27.resolve(targetRoot);
   const rootReal = await realpath2(rootAbs).catch(() => rootAbs);
-  const lineagePath = path26.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path26.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path26.isAbsolute(rel)) {
+  const lineagePath = path27.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path27.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path27.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -22763,19 +22866,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path26.dirname(existing)) {
+  while (existing !== path27.dirname(existing)) {
     const st = await lstat3(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path26.basename(existing));
-    existing = path26.dirname(existing);
+    suffix.unshift(path27.basename(existing));
+    existing = path27.dirname(existing);
   }
   const existingReal = await realpath2(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path26.join(existingReal, ...suffix) : existingReal;
-  const rel = path26.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path27.join(existingReal, ...suffix) : existingReal;
+  const rel = path27.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path26.sep}`)) return false;
-  if (path26.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path27.sep}`)) return false;
+  if (path27.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -22911,4 +23014,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-ZWGXZ7ID.js.map
+//# sourceMappingURL=chunk-PNUOQYRJ.js.map