@remnic/core 9.3.743 → 9.3.744

package/dist/{chunk-VO4VARZL.js → chunk-SODQQCAZ.js}

@@ -512,19 +512,19 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path6 from "path";
+import path7 from "path";
 import os2 from "os";
-import { createHash as createHash2, randomBytes } from "crypto";
+import { createHash as createHash3, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   lstat,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   readdir as readdir2,
   readFile as readFile2,
   realpath,
   stat,
   unlink,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "fs/promises";
 
 // src/procedural/procedure-recall.ts
@@ -2196,7 +2196,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path7, c] of nsMap) counters.set(path7, c);
+        for (const [path8, c] of nsMap) counters.set(path8, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -2281,7 +2281,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path7) => {
+        readMemoryFrontmatter: async (path8) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2292,7 +2292,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
             }
           }
           if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path7, fallbackReader, namespaces);
+          const memory = await this.readQmdResultMemory(path8, fallbackReader, namespaces);
           return memory ? memory.frontmatter : null;
         }
       },
@@ -3016,6 +3016,295 @@ var ContradictionLinkingCoordinator = class {
   }
 };
 
+// src/orchestration/graph-recall-coordinator.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+function mergeGraphExpandedResults(primary, expanded) {
+  const mergedByPath = /* @__PURE__ */ new Map();
+  for (const item of [...primary, ...expanded]) {
+    const prev = mergedByPath.get(item.path);
+    if (!prev) {
+      mergedByPath.set(item.path, item);
+      continue;
+    }
+    const better = item.score > prev.score ? item : prev;
+    const snippet = prev.snippet || item.snippet;
+    mergedByPath.set(item.path, { ...better, snippet });
+  }
+  return Array.from(mergedByPath.values());
+}
+function graphPathRelativeToStorage(storageDir, candidatePath) {
+  const absolutePath = path5.isAbsolute(candidatePath) ? candidatePath : path5.resolve(storageDir, candidatePath);
+  const rel = path5.relative(storageDir, absolutePath);
+  if (!rel || rel === ".") return null;
+  if (rel.startsWith("..")) return null;
+  return rel.split(path5.sep).join("/");
+}
+function normalizeGraphActivationScore(score) {
+  const bounded = Number.isFinite(score) && score > 0 ? score : 0;
+  return bounded / (1 + bounded);
+}
+function blendGraphExpandedRecallScore(options) {
+  const graphNorm = normalizeGraphActivationScore(options.graphActivationScore);
+  const seedScore = Number.isFinite(options.seedRecallScore) ? Math.min(1, Math.max(0, options.seedRecallScore)) : 0;
+  const weight = Math.min(1, Math.max(0, options.activationWeight));
+  const rawMin = Math.min(1, Math.max(0, options.blendMin));
+  const rawMax = Math.min(1, Math.max(0, options.blendMax));
+  const minBound = Math.min(rawMin, rawMax);
+  const maxBound = Math.max(rawMin, rawMax);
+  const blended = graphNorm * weight + seedScore * (1 - weight);
+  return Math.max(minBound, Math.min(maxBound, blended));
+}
+var GraphRecallCoordinator = class {
+  getConfig;
+  getStorage;
+  storageFor;
+  graphIndexFor;
+  namespaceFromPath;
+  resolveColdQmdResultForRecall;
+  storageForAbsoluteQmdResultPath;
+  readQmdResultMemory;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.getStorage = options.getStorage;
+    this.storageFor = options.storageFor;
+    this.graphIndexFor = options.graphIndexFor;
+    this.namespaceFromPath = options.namespaceFromPath;
+    this.resolveColdQmdResultForRecall = options.resolveColdQmdResultForRecall;
+    this.storageForAbsoluteQmdResultPath = options.storageForAbsoluteQmdResultPath;
+    this.readQmdResultMemory = options.readQmdResultMemory;
+  }
+  async expandResultsViaGraph(options) {
+    const config = this.getConfig();
+    const deadlineExpired = () => typeof options.deadlineAtMs === "number" && Date.now() >= options.deadlineAtMs;
+    const byNamespace = /* @__PURE__ */ new Map();
+    const addResultForNamespace = (namespace, result) => {
+      const existing = byNamespace.get(namespace);
+      if (existing) {
+        existing.push(result);
+      } else {
+        byNamespace.set(namespace, [result]);
+      }
+    };
+    const resolvedAmbiguousSeeds = /* @__PURE__ */ new Map();
+    const resolveAmbiguousSeedOwner = async (result, parts) => {
+      const cached = resolvedAmbiguousSeeds.get(result.path);
+      if (cached !== void 0) return cached;
+      if (deadlineExpired()) {
+        resolvedAmbiguousSeeds.set(result.path, null);
+        return null;
+      }
+      let resolvedPath = result.path;
+      let resolvedResult = result;
+      if (parts) {
+        const resolvedCold = await this.resolveColdQmdResultForRecall(
+          result,
+          this.getStorage(),
+          options.recallNamespaces
+        );
+        if (!resolvedCold || deadlineExpired()) {
+          resolvedAmbiguousSeeds.set(result.path, null);
+          return null;
+        }
+        resolvedPath = resolvedCold.result.path;
+        resolvedResult = resolvedCold.result;
+      }
+      if (!path5.isAbsolute(resolvedPath)) {
+        resolvedAmbiguousSeeds.set(result.path, null);
+        return null;
+      }
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        resolvedPath,
+        this.getStorage(),
+        options.recallNamespaces
+      );
+      const ownerNamespace = ownerStorage?.namespace ?? null;
+      const resolved = ownerNamespace && options.recallNamespaces.includes(ownerNamespace) ? { namespace: ownerNamespace, result: resolvedResult } : null;
+      resolvedAmbiguousSeeds.set(result.path, resolved);
+      return resolved;
+    };
+    const coldCollection = config.qmdColdCollection ?? "openclaw-engram-cold";
+    for (const result of options.memoryResults) {
+      if (deadlineExpired()) break;
+      const parts = qmdCollectionPathParts(result.path);
+      if (parts?.collection === coldCollection) {
+        const resolved = await resolveAmbiguousSeedOwner(result, parts);
+        if (resolved) {
+          addResultForNamespace(resolved.namespace, resolved.result);
+        }
+        continue;
+      }
+      if (path5.isAbsolute(result.path)) {
+        const resolved = await resolveAmbiguousSeedOwner(result, null);
+        if (resolved) {
+          addResultForNamespace(resolved.namespace, resolved.result);
+        }
+        continue;
+      }
+      const ns = this.namespaceFromPath(result.path);
+      if (!options.recallNamespaces.includes(ns)) continue;
+      addResultForNamespace(ns, result);
+    }
+    const perNamespaceSeedCap = Math.max(3, options.recallResultLimit);
+    const perNamespaceExpandedCap = Math.max(8, options.recallResultLimit * 2);
+    const seedPaths = [];
+    const seedResults = [];
+    const expandedPaths = [];
+    const expandedResults = [];
+    for (const [namespace, nsResults] of byNamespace.entries()) {
+      if (deadlineExpired()) break;
+      const storage = await this.storageFor(namespace);
+      const seedCandidates = nsResults.slice(0, perNamespaceSeedCap);
+      seedResults.push(...seedCandidates);
+      const seedRelativePaths = typeof options.deadlineAtMs === "number" ? await this.graphSeedPathsWithinDeadline(
+        storage,
+        seedCandidates,
+        options.deadlineAtMs,
+        [namespace]
+      ) : (await Promise.all(
+        seedCandidates.map(
+          (result) => this.graphSeedPathRelativeToStorage(storage, result, [
+            namespace
+          ])
+        )
+      )).filter(
+        (value) => typeof value === "string" && value.length > 0
+      );
+      if (deadlineExpired()) break;
+      if (seedRelativePaths.length === 0) continue;
+      const seedRecallScore = seedCandidates.reduce(
+        (max, item) => Math.max(max, item.score),
+        0
+      );
+      seedPaths.push(
+        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
+      );
+      const seedSet = new Set(seedRelativePaths);
+      const expanded = await this.graphIndexFor(storage).spreadingActivation(
+        seedRelativePaths,
+        config.maxGraphTraversalSteps,
+        {
+          ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
+          ...typeof options.deadlineAtMs === "number" ? { deadlineAtMs: options.deadlineAtMs } : {}
+        }
+      );
+      if (expanded.length === 0) continue;
+      if (deadlineExpired()) break;
+      for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
+        if (deadlineExpired()) break;
+        if (seedSet.has(candidate.path)) continue;
+        const memoryPath = path5.resolve(storage.dir, candidate.path);
+        const memory = await storage.readMemoryByPath(memoryPath);
+        if (deadlineExpired()) break;
+        if (!memory) continue;
+        if (/(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(memory.path)) continue;
+        if (memory.frontmatter.status && memory.frontmatter.status !== "active")
+          continue;
+        const snippet = memory.content.slice(0, 400);
+        const score = blendGraphExpandedRecallScore({
+          graphActivationScore: candidate.score,
+          seedRecallScore,
+          activationWeight: config.graphExpansionActivationWeight,
+          blendMin: config.graphExpansionBlendMin,
+          blendMax: config.graphExpansionBlendMax
+        });
+        expandedResults.push({
+          docid: memory.frontmatter.id,
+          path: memory.path,
+          snippet,
+          score
+        });
+        expandedPaths.push({
+          path: memory.path,
+          score,
+          namespace,
+          seed: path5.resolve(storage.dir, candidate.seed),
+          hopDepth: candidate.hopDepth,
+          decayedWeight: candidate.decayedWeight,
+          graphType: candidate.graphType,
+          // Issue #681 PR 3/3 — surface the per-edge confidence used for
+          // PageRank weighting / floor pruning so downstream observability
+          // (recall_xray, memory_graph_explain) can attribute ranking and
+          // pruning decisions to specific edges.
+          edgeConfidence: candidate.edgeConfidence
+        });
+      }
+    }
+    return {
+      merged: mergeGraphExpandedResults(options.memoryResults, expandedResults),
+      seedPaths,
+      expandedPaths,
+      seedResults
+    };
+  }
+  async recordLastGraphRecallSnapshot(options) {
+    try {
+      const snapshotPath = path5.join(
+        options.storage.dir,
+        "state",
+        "last_graph_recall.json"
+      );
+      await mkdir2(path5.dirname(snapshotPath), { recursive: true });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const totalSeedCount = options.seedPaths.length;
+      const totalExpandedCount = options.expandedPaths.length;
+      const seeds = options.seedPaths.slice(0, 64);
+      const expanded = clampGraphRecallExpandedEntries(
+        options.expandedPaths,
+        64
+      );
+      const payload = {
+        recordedAt: now,
+        mode: options.recallMode,
+        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
+        queryLength: options.prompt.length,
+        namespaces: options.recallNamespaces,
+        seedCount: totalSeedCount,
+        expandedCount: totalExpandedCount,
+        seeds,
+        expanded,
+        status: options.status,
+        reason: options.reason,
+        shadowMode: options.shadowMode === true,
+        queryIntent: options.queryIntent,
+        seedResults: (options.seedResults ?? []).slice(0, 64),
+        finalResults: (options.finalResults ?? []).slice(0, 64),
+        shadowComparison: options.shadowComparison
+      };
+      await writeFile2(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+    } catch (err) {
+      log.debug(`last graph recall write failed: ${err}`);
+    }
+  }
+  async graphSeedPathRelativeToStorage(storage, result, recallNamespaces = []) {
+    const parts = qmdCollectionPathParts(result.path);
+    if (parts) {
+      const memory = await this.readQmdResultMemory(
+        result.path,
+        storage,
+        recallNamespaces
+      );
+      return memory ? graphPathRelativeToStorage(storage.dir, memory.path) : null;
+    }
+    return graphPathRelativeToStorage(storage.dir, result.path);
+  }
+  async graphSeedPathsWithinDeadline(storage, results, deadlineAtMs, recallNamespaces = []) {
+    const resolved = [];
+    for (const result of results) {
+      if (Date.now() >= deadlineAtMs) break;
+      const seedPath = await this.graphSeedPathRelativeToStorage(
+        storage,
+        result,
+        recallNamespaces
+      );
+      if (Date.now() >= deadlineAtMs) break;
+      if (seedPath) resolved.push(seedPath);
+    }
+    return resolved;
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -3348,8 +3637,8 @@ function generateResolverDocument(taxonomy) {
 }
 
 // src/taxonomy/taxonomy-loader.ts
-import { readFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+import { readFile, mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -3447,7 +3736,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path6.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile(taxonomyPath, "utf-8");
@@ -3497,16 +3786,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path5.join(memoryDir, TAXONOMY_DIR);
-  await mkdir2(dir, { recursive: true });
-  const filePath = path5.join(dir, TAXONOMY_FILE);
-  await writeFile2(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
+  const dir = path6.join(memoryDir, TAXONOMY_DIR);
+  await mkdir3(dir, { recursive: true });
+  const filePath = path6.join(dir, TAXONOMY_FILE);
+  await writeFile3(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path5.join(memoryDir, TAXONOMY_DIR);
+  return path6.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path6.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/wearables/registry.ts
@@ -4516,11 +4805,11 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path6.join(os2.homedir(), ".openclaw", "workspace");
+  return path7.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const hash = createHash2("sha256").update(sessionKey).digest("hex").slice(0, 12);
+  const hash = createHash3("sha256").update(sessionKey).digest("hex").slice(0, 12);
   return `${readable}-${hash}`;
 }
 function latestSourceValidAtFromTurns(turns) {
@@ -4778,42 +5067,6 @@ function computeQmdHybridFetchLimit(recallFetchLimit, artifactsEnabled, maxArtif
   const artifactHeadroom = Math.max(20, Math.max(0, maxArtifactRecall) * 8);
   return Math.min(400, cappedRecallLimit + artifactHeadroom);
 }
-function mergeGraphExpandedResults(primary, expanded) {
-  const mergedByPath = /* @__PURE__ */ new Map();
-  for (const item of [...primary, ...expanded]) {
-    const prev = mergedByPath.get(item.path);
-    if (!prev) {
-      mergedByPath.set(item.path, item);
-      continue;
-    }
-    const better = item.score > prev.score ? item : prev;
-    const snippet = prev.snippet || item.snippet;
-    mergedByPath.set(item.path, { ...better, snippet });
-  }
-  return Array.from(mergedByPath.values());
-}
-function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path6.isAbsolute(candidatePath) ? candidatePath : path6.resolve(storageDir, candidatePath);
-  const rel = path6.relative(storageDir, absolutePath);
-  if (!rel || rel === ".") return null;
-  if (rel.startsWith("..")) return null;
-  return rel.split(path6.sep).join("/");
-}
-function normalizeGraphActivationScore(score) {
-  const bounded = Number.isFinite(score) && score > 0 ? score : 0;
-  return bounded / (1 + bounded);
-}
-function blendGraphExpandedRecallScore(options) {
-  const graphNorm = normalizeGraphActivationScore(options.graphActivationScore);
-  const seedScore = Number.isFinite(options.seedRecallScore) ? Math.min(1, Math.max(0, options.seedRecallScore)) : 0;
-  const weight = Math.min(1, Math.max(0, options.activationWeight));
-  const rawMin = Math.min(1, Math.max(0, options.blendMin));
-  const rawMax = Math.min(1, Math.max(0, options.blendMax));
-  const minBound = Math.min(rawMin, rawMax);
-  const maxBound = Math.max(rawMin, rawMax);
-  const blended = graphNorm * weight + seedScore * (1 - weight);
-  return Math.max(minBound, Math.min(maxBound, blended));
-}
 function summarizeGraphShadowComparison(baseline, merged, topN) {
   const limit = Math.max(0, Math.floor(topN));
   const baselineTop = limit > 0 ? baseline.slice(0, limit) : [];
@@ -4942,7 +5195,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path6.relative(storageDir, mem.path));
+    pathById.set(id, path7.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -4950,7 +5203,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path6.join(options.storageDir, options.memoryRelPath),
+    path: path7.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -4970,16 +5223,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path6.join("corrections", `${options.memoryId}.md`);
+    return path7.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 path6.join(subtree, day, `${options.memoryId}.md`);
+    return path7.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path6.join(subtree, `${options.memoryId}.md`);
+  return path7.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -5144,6 +5397,7 @@ var Orchestrator = class _Orchestrator {
   recallSectionCoordinator;
   qmdResultResolver;
   contradictionLinkingCoordinator;
+  graphRecallCoordinator;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
@@ -5436,7 +5690,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 = path6.resolve(storageDir);
+    const resolvedStorageDir = path7.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -5447,21 +5701,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path6.resolve(storageDir);
-    const resolvedMemoryDir = path6.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path7.resolve(storageDir);
+    const resolvedMemoryDir = path7.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path6.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path7.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path6.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path6.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path7.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path7.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path6.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path7.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path6.basename(resolvedStorageDir);
+    const leaf = path7.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -5489,7 +5743,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path6.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path7.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -5526,7 +5780,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path6.resolve(record.storageDir);
+      const resolvedStorageDir = path7.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -5790,7 +6044,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path6.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path7.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -5860,7 +6114,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 = path6.join(
+    this.conversationIndexDir = path7.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -5890,6 +6144,16 @@ var Orchestrator = class _Orchestrator {
       getExtraction: () => this.extraction
     });
     this.modelRegistry = new ModelRegistry(config.memoryDir);
+    this.graphRecallCoordinator = new GraphRecallCoordinator({
+      getConfig: () => this.config,
+      getStorage: () => this.storage,
+      storageFor: (namespace) => this.storageRouter.storageFor(namespace),
+      graphIndexFor: (storage) => this.graphIndexFor(storage),
+      namespaceFromPath: (p) => this.namespaceFromPath(p),
+      resolveColdQmdResultForRecall: (result, fallbackStorage, recallNamespaces) => this.resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces),
+      storageForAbsoluteQmdResultPath: (resultPath, fallbackStorage, recallNamespaces) => this.storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces),
+      readQmdResultMemory: (resultPath, fallbackStorage, recallNamespaces) => this.readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces)
+    });
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
     this.lastRecall = new LastRecallStore(config.memoryDir);
@@ -5986,7 +6250,7 @@ var Orchestrator = class _Orchestrator {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path6.join(config.memoryDir, "threads"),
+      path7.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -6066,7 +6330,7 @@ var Orchestrator = class _Orchestrator {
       utilityPromoteThresholdDelta: this.utilityRuntimeValues?.promoteThresholdDelta ?? 0,
       utilityDemoteThresholdDelta: this.utilityRuntimeValues?.demoteThresholdDelta ?? 0
     };
-    return createHash2("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
+    return createHash3("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
   }
   effectiveLifecycleThresholds() {
     const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
@@ -6309,7 +6573,7 @@ var Orchestrator = class _Orchestrator {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path6.join(wsDir, f);
+            const fp = path7.join(wsDir, f);
             const s = await stat(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink(fp).catch(() => {
@@ -6818,15 +7082,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path6.isAbsolute(rel) ? rel : path6.join(this.config.workspaceDir, rel);
+        const abs = path7.isAbsolute(rel) ? rel : path7.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path6.join(
+            const archiveDir = path7.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path6.basename(abs);
+            const base = path7.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -6834,7 +7098,7 @@ ${doc.content}` : doc.content,
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile3(abs, newContent, "utf-8");
+            await writeFile4(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -6851,8 +7115,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path6.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir3(path6.dirname(fp), { recursive: true });
+        const fp = path7.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir4(path7.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -6865,7 +7129,7 @@ ${doc.content}` : doc.content,
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile3(fp, existing + block, "utf-8");
+        await writeFile4(fp, existing + block, "utf-8");
       }
     }
   }
@@ -6991,7 +7255,7 @@ ${doc.content}` : doc.content,
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path6.join(storage.dir, categoryDir, date);
+        const dateDir = path7.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -7000,7 +7264,7 @@ ${doc.content}` : doc.content,
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path6.join(dateDir, entry.name);
+            const fullPath = path7.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile2(fullPath, "utf-8");
@@ -7022,7 +7286,7 @@ ${doc.content}` : doc.content,
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path6.basename(entry.name, ".md"),
+                  id: fm.id || path7.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -7045,13 +7309,13 @@ ${doc.content}` : doc.content,
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path6.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path7.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir2(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path6.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path7.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -7155,7 +7419,7 @@ ${doc.content}` : doc.content,
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path6.join(
+    const snapshotPath = path7.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -7194,7 +7458,7 @@ ${doc.content}` : doc.content,
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path6.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path7.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -7227,7 +7491,7 @@ ${doc.content}` : doc.content,
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path6.join(
+    const snapshotPath = path7.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -7929,7 +8193,7 @@ ${doc.content}` : doc.content,
       if (!options.onDebugSnapshot) return;
       await options.onDebugSnapshot({
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        queryHash: createHash2("sha256").update(prompt).digest("hex"),
+        queryHash: createHash3("sha256").update(prompt).digest("hex"),
         queryLength: prompt.length,
         collection: options.collection,
         namespaces: options.recallNamespaces,
@@ -8077,216 +8341,26 @@ ${doc.content}` : doc.content,
     await emitDebugSnapshot(capped, fetchLimit);
     return capped;
   }
+  // Issue #1526 (seam 14): graph-recall expansion moved to
+  // GraphRecallCoordinator. Thin delegation keeps the private API stable
+  // for callers (recallInternal, cold-fallback pipeline) + tests.
   async expandResultsViaGraph(options) {
-    const deadlineExpired = () => typeof options.deadlineAtMs === "number" && Date.now() >= options.deadlineAtMs;
-    const byNamespace = /* @__PURE__ */ new Map();
-    const addResultForNamespace = (namespace, result) => {
-      const existing = byNamespace.get(namespace);
-      if (existing) {
-        existing.push(result);
-      } else {
-        byNamespace.set(namespace, [result]);
-      }
-    };
-    const resolvedAmbiguousSeeds = /* @__PURE__ */ new Map();
-    const resolveAmbiguousSeedOwner = async (result, parts) => {
-      const cached = resolvedAmbiguousSeeds.get(result.path);
-      if (cached !== void 0) return cached;
-      if (deadlineExpired()) {
-        resolvedAmbiguousSeeds.set(result.path, null);
-        return null;
-      }
-      let resolvedPath = result.path;
-      let resolvedResult = result;
-      if (parts) {
-        const resolvedCold = await this.resolveColdQmdResultForRecall(
-          result,
-          this.storage,
-          options.recallNamespaces
-        );
-        if (!resolvedCold || deadlineExpired()) {
-          resolvedAmbiguousSeeds.set(result.path, null);
-          return null;
-        }
-        resolvedPath = resolvedCold.result.path;
-        resolvedResult = resolvedCold.result;
-      }
-      if (!path6.isAbsolute(resolvedPath)) {
-        resolvedAmbiguousSeeds.set(result.path, null);
-        return null;
-      }
-      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        resolvedPath,
-        this.storage,
-        options.recallNamespaces
-      );
-      const ownerNamespace = ownerStorage?.namespace ?? null;
-      const resolved = ownerNamespace && options.recallNamespaces.includes(ownerNamespace) ? { namespace: ownerNamespace, result: resolvedResult } : null;
-      resolvedAmbiguousSeeds.set(result.path, resolved);
-      return resolved;
-    };
-    const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
-    for (const result of options.memoryResults) {
-      if (deadlineExpired()) break;
-      const parts = qmdCollectionPathParts(result.path);
-      if (parts?.collection === coldCollection) {
-        const resolved = await resolveAmbiguousSeedOwner(result, parts);
-        if (resolved) {
-          addResultForNamespace(resolved.namespace, resolved.result);
-        }
-        continue;
-      }
-      if (path6.isAbsolute(result.path)) {
-        const resolved = await resolveAmbiguousSeedOwner(result, null);
-        if (resolved) {
-          addResultForNamespace(resolved.namespace, resolved.result);
-        }
-        continue;
-      }
-      const ns = this.namespaceFromPath(result.path);
-      if (!options.recallNamespaces.includes(ns)) continue;
-      addResultForNamespace(ns, result);
-    }
-    const perNamespaceSeedCap = Math.max(3, options.recallResultLimit);
-    const perNamespaceExpandedCap = Math.max(8, options.recallResultLimit * 2);
-    const seedPaths = [];
-    const seedResults = [];
-    const expandedPaths = [];
-    const expandedResults = [];
-    for (const [namespace, nsResults] of byNamespace.entries()) {
-      if (deadlineExpired()) break;
-      const storage = await this.storageRouter.storageFor(namespace);
-      const seedCandidates = nsResults.slice(0, perNamespaceSeedCap);
-      seedResults.push(...seedCandidates);
-      const seedRelativePaths = typeof options.deadlineAtMs === "number" ? await this.graphSeedPathsWithinDeadline(
-        storage,
-        seedCandidates,
-        options.deadlineAtMs,
-        [namespace]
-      ) : (await Promise.all(
-        seedCandidates.map(
-          (result) => this.graphSeedPathRelativeToStorage(storage, result, [
-            namespace
-          ])
-        )
-      )).filter(
-        (value) => typeof value === "string" && value.length > 0
-      );
-      if (deadlineExpired()) break;
-      if (seedRelativePaths.length === 0) continue;
-      const seedRecallScore = seedCandidates.reduce(
-        (max, item) => Math.max(max, item.score),
-        0
-      );
-      seedPaths.push(
-        ...seedRelativePaths.map((rel) => path6.join(storage.dir, rel))
-      );
-      const seedSet = new Set(seedRelativePaths);
-      const expanded = await this.graphIndexFor(storage).spreadingActivation(
-        seedRelativePaths,
-        this.config.maxGraphTraversalSteps,
-        {
-          ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
-          ...typeof options.deadlineAtMs === "number" ? { deadlineAtMs: options.deadlineAtMs } : {}
-        }
-      );
-      if (expanded.length === 0) continue;
-      if (deadlineExpired()) break;
-      for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
-        if (deadlineExpired()) break;
-        if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path6.resolve(storage.dir, candidate.path);
-        const memory = await storage.readMemoryByPath(memoryPath);
-        if (deadlineExpired()) break;
-        if (!memory) continue;
-        if (isArtifactMemoryPath(memory.path)) continue;
-        if (memory.frontmatter.status && memory.frontmatter.status !== "active")
-          continue;
-        const snippet = memory.content.slice(0, 400);
-        const score = blendGraphExpandedRecallScore({
-          graphActivationScore: candidate.score,
-          seedRecallScore,
-          activationWeight: this.config.graphExpansionActivationWeight,
-          blendMin: this.config.graphExpansionBlendMin,
-          blendMax: this.config.graphExpansionBlendMax
-        });
-        expandedResults.push({
-          docid: memory.frontmatter.id,
-          path: memory.path,
-          snippet,
-          score
-        });
-        expandedPaths.push({
-          path: memory.path,
-          score,
-          namespace,
-          seed: path6.resolve(storage.dir, candidate.seed),
-          hopDepth: candidate.hopDepth,
-          decayedWeight: candidate.decayedWeight,
-          graphType: candidate.graphType,
-          // Issue #681 PR 3/3 — surface the per-edge confidence used for
-          // PageRank weighting / floor pruning so downstream observability
-          // (recall_xray, memory_graph_explain) can attribute ranking and
-          // pruning decisions to specific edges.
-          edgeConfidence: candidate.edgeConfidence
-        });
-      }
-    }
-    return {
-      merged: mergeGraphExpandedResults(options.memoryResults, expandedResults),
-      seedPaths,
-      expandedPaths,
-      seedResults
-    };
+    return this.graphRecallCoordinator.expandResultsViaGraph(options);
   }
+  // Issue #1526 (seam 14): graph-recall snapshot moved to
+  // GraphRecallCoordinator. Thin delegation keeps the private API stable.
   async recordLastGraphRecallSnapshot(options) {
-    try {
-      const snapshotPath = path6.join(
-        options.storage.dir,
-        "state",
-        "last_graph_recall.json"
-      );
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const totalSeedCount = options.seedPaths.length;
-      const totalExpandedCount = options.expandedPaths.length;
-      const seeds = options.seedPaths.slice(0, 64);
-      const expanded = clampGraphRecallExpandedEntries(
-        options.expandedPaths,
-        64
-      );
-      const payload = {
-        recordedAt: now,
-        mode: options.recallMode,
-        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
-        queryLength: options.prompt.length,
-        namespaces: options.recallNamespaces,
-        seedCount: totalSeedCount,
-        expandedCount: totalExpandedCount,
-        seeds,
-        expanded,
-        status: options.status,
-        reason: options.reason,
-        shadowMode: options.shadowMode === true,
-        queryIntent: options.queryIntent,
-        seedResults: (options.seedResults ?? []).slice(0, 64),
-        finalResults: (options.finalResults ?? []).slice(0, 64),
-        shadowComparison: options.shadowComparison
-      };
-      await writeFile3(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
-    } catch (err) {
-      log.debug(`last graph recall write failed: ${err}`);
-    }
+    return this.graphRecallCoordinator.recordLastGraphRecallSnapshot(options);
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path6.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir4(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -8297,13 +8371,13 @@ ${doc.content}` : doc.content,
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path6.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir4(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -8317,9 +8391,9 @@ ${doc.content}` : doc.content,
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path6.join(stateDir, "last_intent.json");
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      const snapshotPath = path7.join(stateDir, "last_intent.json");
+      await mkdir4(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -8330,12 +8404,12 @@ ${doc.content}` : doc.content,
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path6.join(this.config.memoryDir, "state");
+      return path7.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path6.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path7.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path6.join(
+    const candidate = path7.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -8343,11 +8417,11 @@ ${doc.content}` : doc.content,
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path6.join(candidate, "state");
+        return path7.join(candidate, "state");
       }
     } catch {
     }
-    return path6.join(this.config.memoryDir, "state");
+    return path7.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -8478,8 +8552,8 @@ ${doc.content}` : doc.content,
         timings,
         logger: log
       });
-      const promptHash = createHash2("sha256").update(prompt).digest("hex");
-      const traceId = createHash2("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
+      const promptHash = createHash3("sha256").update(prompt).digest("hex");
+      const traceId = createHash3("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
       const sectionBuckets = /* @__PURE__ */ new Map();
       const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
         cronRecallPolicyEnabled: resolveRecallAuxiliaryCapabilities(this.config).cronRecallPolicy,
@@ -8488,7 +8562,7 @@ ${doc.content}` : doc.content,
         cronConversationRecallMode: this.config.cronConversationRecallMode
       });
       const retrievalQuery = queryPolicy.retrievalQuery || prompt;
-      const retrievalQueryHash = createHash2("sha256").update(retrievalQuery).digest("hex");
+      const retrievalQueryHash = createHash3("sha256").update(retrievalQuery).digest("hex");
       const policyVersion = this.currentPolicyVersion();
       let impressionRecorded = false;
       let recallSource = "none";
@@ -8627,7 +8701,7 @@ ${doc.content}` : doc.content,
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path6.sep).join("/");
+        const normalizedPath = resultPath.split(path7.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -8777,7 +8851,7 @@ ${doc.content}` : doc.content,
         profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path6.join(this.config.memoryDir, ".empty-scope-profile") },
+        { dir: path7.join(this.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -10253,11 +10327,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path6.join(
+        const signalPath = path7.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path6.join(workspaceDir, "BOOT.md");
+        const bootPath = path7.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -12528,7 +12602,7 @@ _Context: ${topQuestion.context}_`
     const shouldUseStableBatchKey = turns.some(
       (turn) => turn.persistProcessedFingerprint === true || typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0
     );
-    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash2("sha256").update(
+    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash3("sha256").update(
       turns.map(
         (turn) => [
           turn.role,
@@ -12778,7 +12852,7 @@ _Context: ${topQuestion.context}_`
   buildExtractionFingerprint(turns, bufferKey) {
     const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
     if (!normalized) return null;
-    return createHash2("sha256").update(`${bufferKey}
+    return createHash3("sha256").update(`${bufferKey}
 ${normalized}`).digest("hex");
   }
   shouldQueueExtraction(turns, options = {}) {
@@ -14859,7 +14933,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path6.relative(storage.dir, m.path);
+            const rel = path7.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -15183,7 +15257,7 @@ ${normalized}`).digest("hex");
     }
     if (resolveConsolidationCapabilities(this.config).semanticConsolidation) {
       try {
-        const stateFilePath = path6.join(
+        const stateFilePath = path7.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -15231,9 +15305,9 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path6.join(this.config.memoryDir, "state");
-            await mkdir3(stateDir, { recursive: true });
-            await writeFile3(
+            const stateDir = path7.join(this.config.memoryDir, "state");
+            await mkdir4(stateDir, { recursive: true });
+            await writeFile4(
               stateFilePath,
               JSON.stringify({ lastRunAt: (/* @__PURE__ */ new Date()).toISOString() }),
               "utf-8"
@@ -15627,12 +15701,12 @@ ${reflectionsContent.trim()}
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path6.resolve(this.config.memoryDir);
-    const storageDir = path6.resolve(targetStorage.dir);
+    const memoryDir = path7.resolve(this.config.memoryDir);
+    const storageDir = path7.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path6.relative(memoryDir, storageDir);
+    let rel = path7.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`
@@ -15651,7 +15725,7 @@ ${reflectionsContent.trim()}
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path6.isAbsolute(hit.path) ? hit.path : path6.join(this.config.memoryDir, hit.path);
+      const fullPath = path7.isAbsolute(hit.path) ? hit.path : path7.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -15848,7 +15922,7 @@ ${reflectionsContent.trim()}
           const storage = await this.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path6.resolve(storageDir);
+          const recallRoot = path7.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -15872,8 +15946,8 @@ ${reflectionsContent.trim()}
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path6.isAbsolute(result.path)) {
-          const resolvedPath = path6.resolve(result.path);
+        if (path7.isAbsolute(result.path)) {
+          const resolvedPath = path7.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -16574,32 +16648,6 @@ ${reflectionsContent.trim()}
       namespaceScope
     );
   }
-  async graphSeedPathRelativeToStorage(storage, result, recallNamespaces = []) {
-    const parts = qmdCollectionPathParts(result.path);
-    if (parts) {
-      const memory = await this.readQmdResultMemory(
-        result.path,
-        storage,
-        recallNamespaces
-      );
-      return memory ? graphPathRelativeToStorage(storage.dir, memory.path) : null;
-    }
-    return graphPathRelativeToStorage(storage.dir, result.path);
-  }
-  async graphSeedPathsWithinDeadline(storage, results, deadlineAtMs, recallNamespaces = []) {
-    const resolved = [];
-    for (const result of results) {
-      if (Date.now() >= deadlineAtMs) break;
-      const seedPath = await this.graphSeedPathRelativeToStorage(
-        storage,
-        result,
-        recallNamespaces
-      );
-      if (Date.now() >= deadlineAtMs) break;
-      if (seedPath) resolved.push(seedPath);
-    }
-    return resolved;
-  }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return this.config.defaultNamespace;
     const parts = qmdCollectionPathParts(p);
@@ -16659,6 +16707,9 @@ export {
   buildProcedureRecallSection,
   hasIdentityRecoveryIntent,
   resolveEffectiveIdentityInjectionMode,
+  mergeGraphExpandedResults,
+  graphPathRelativeToStorage,
+  blendGraphExpandedRecallScore,
   decideSemanticDedup,
   DEFAULT_TAXONOMY,
   generateResolverDocument,
@@ -16690,9 +16741,6 @@ export {
   resolveRecallModeDecisionAsync,
   computeArtifactCandidateFetchLimit,
   computeQmdHybridFetchLimit,
-  mergeGraphExpandedResults,
-  graphPathRelativeToStorage,
-  blendGraphExpandedRecallScore,
   summarizeGraphShadowComparison,
   mergeArtifactRecallCandidates,
   resolveRecentThreadMemoryPaths,
@@ -16701,4 +16749,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-VO4VARZL.js.map
+//# sourceMappingURL=chunk-SODQQCAZ.js.map