@remnic/core 9.3.738 → 9.3.739

package/dist/{chunk-EKQ3LWBM.js → chunk-IEWUPZ75.js}

@@ -509,14 +509,14 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path4 from "path";
+import path5 from "path";
 import os2 from "os";
 import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   lstat,
   mkdir as mkdir3,
-  readdir,
+  readdir as readdir2,
   readFile as readFile2,
   realpath,
   stat,
@@ -1942,6 +1942,452 @@ ${lines.join("\n\n")}`;
   }
 };
 
+// src/orchestration/conversation-index-coordinator.ts
+import { readdir } from "fs/promises";
+import path3 from "path";
+var ConversationIndexCoordinator = class {
+  config;
+  getTranscript;
+  getBackend;
+  indexDir;
+  lastUpdateAtMs = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.config = options.config;
+    this.getTranscript = options.getTranscript;
+    this.getBackend = options.getBackend;
+    this.indexDir = options.indexDir;
+  }
+  /** Semantic recall over past-conversation chunks (fail-open: empty on miss). */
+  async search(retrievalQuery, topK) {
+    const backend = this.getBackend();
+    if (backend) {
+      return backend.search(retrievalQuery, topK);
+    }
+    return [];
+  }
+  /** Render conversation-recall search hits as a budgeted markdown section. */
+  formatRecallSection(results, maxChars) {
+    if (!Array.isArray(results) || results.length === 0) return null;
+    const lines = ["## Semantic Recall (Past Conversations)", ""];
+    let used = 0;
+    for (const r of results) {
+      if (!r?.snippet) continue;
+      const chunk = `### ${r.path}
+Score: ${r.score.toFixed(3)}
+
+${r.snippet.trim()}
+`;
+      if (used + chunk.length > maxChars) break;
+      lines.push(chunk);
+      used += chunk.length;
+    }
+    return used > 0 ? lines.join("\n") : null;
+  }
+  /** Recursively count `.md` chunk documents under a directory. */
+  async countChunkDocs(dir) {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      let total = 0;
+      for (const entry of entries) {
+        const fullPath = path3.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          total += await this.countChunkDocs(fullPath);
+          continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          total += 1;
+        }
+      }
+      return total;
+    } catch {
+      return 0;
+    }
+  }
+  /** Read recent transcript entries and chunk them for indexing. */
+  async buildChunks(sessionKey, hours = 24) {
+    const entries = await this.getTranscript().readRecent(hours, sessionKey);
+    const effectiveSessionKey = sessionKey ?? "all-sessions";
+    return chunkTranscriptEntries(effectiveSessionKey, entries, {
+      maxChars: this.config.conversationRecallMaxChars * 2,
+      maxTurns: Math.max(10, this.config.hourlySummariesMaxTurnsPerRun)
+    });
+  }
+  async getHealth() {
+    const chunkDocCount = await this.countChunkDocs(this.indexDir);
+    const lastUpdateAtMs = Math.max(0, ...this.lastUpdateAtMs.values());
+    const lastUpdateAt = lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
+      return {
+        enabled: false,
+        backend: this.config.conversationIndexBackend,
+        status: "disabled",
+        chunkDocCount,
+        lastUpdateAt
+      };
+    }
+    const backend = this.getBackend();
+    const backendHealth = backend ? await backend.health() : {
+      backend: this.config.conversationIndexBackend,
+      status: "degraded"
+    };
+    return {
+      enabled: true,
+      chunkDocCount,
+      lastUpdateAt,
+      ...backendHealth
+    };
+  }
+  async inspect() {
+    const chunkDocCount = await this.countChunkDocs(this.indexDir);
+    const lastUpdateAtMs = Math.max(0, ...this.lastUpdateAtMs.values());
+    const lastUpdateAt = lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
+      return {
+        enabled: false,
+        backend: this.config.conversationIndexBackend,
+        status: "disabled",
+        available: false,
+        indexPath: this.indexDir,
+        supportsIncrementalUpdate: true,
+        message: "Conversation index disabled by config",
+        metadata: {
+          chunkCount: chunkDocCount
+        },
+        chunkDocCount,
+        lastUpdateAt
+      };
+    }
+    const backend = this.getBackend();
+    const inspection = backend ? await backend.inspect() : {
+      backend: this.config.conversationIndexBackend,
+      status: "degraded",
+      available: false,
+      indexPath: this.indexDir,
+      supportsIncrementalUpdate: true,
+      message: "Conversation index backend unavailable",
+      metadata: {
+        chunkCount: chunkDocCount
+      }
+    };
+    return {
+      enabled: true,
+      chunkDocCount,
+      lastUpdateAt,
+      ...inspection
+    };
+  }
+  async update(sessionKey, hours = 24, opts) {
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
+      return { chunks: 0, skipped: true, reason: "disabled", embedded: false };
+    }
+    const enforceMinInterval = opts?.enforceMinInterval !== false;
+    if (enforceMinInterval) {
+      const minIntervalMs = Math.max(
+        0,
+        this.config.conversationIndexMinUpdateIntervalMs
+      );
+      const now = Date.now();
+      const last = this.lastUpdateAtMs.get(sessionKey) ?? 0;
+      const elapsed = now - last;
+      if (minIntervalMs > 0 && elapsed < minIntervalMs) {
+        return {
+          chunks: 0,
+          skipped: true,
+          reason: "min_interval",
+          retryAfterMs: minIntervalMs - elapsed,
+          embedded: false
+        };
+      }
+    }
+    const chunks = await this.buildChunks(sessionKey, hours);
+    await writeConversationChunks(this.indexDir, chunks);
+    const retentionCutoffMs = Number.isFinite(this.config.conversationIndexRetentionDays) && this.config.conversationIndexRetentionDays > 0 ? Date.now() - this.config.conversationIndexRetentionDays * 24 * 60 * 60 * 1e3 : void 0;
+    await cleanupConversationChunks(
+      this.indexDir,
+      this.config.conversationIndexRetentionDays
+    );
+    const shouldEmbed = opts?.embed ?? this.config.conversationIndexEmbedOnUpdate;
+    let embedded = false;
+    const backend = this.getBackend();
+    if (backend) {
+      const result = await backend.update(chunks, {
+        embed: shouldEmbed,
+        ...retentionCutoffMs !== void 0 ? { retentionCutoffMs } : {}
+      });
+      embedded = result.embedded;
+    }
+    this.lastUpdateAtMs.set(sessionKey, Date.now());
+    return { chunks: chunks.length, skipped: false, embedded };
+  }
+  async rebuild(sessionKey, hours = 24, opts) {
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
+      return {
+        chunks: 0,
+        skipped: true,
+        reason: "disabled",
+        embedded: false,
+        rebuilt: false
+      };
+    }
+    const chunks = await this.buildChunks(sessionKey, hours);
+    await writeConversationChunks(this.indexDir, chunks);
+    await cleanupConversationChunks(
+      this.indexDir,
+      this.config.conversationIndexRetentionDays
+    );
+    const shouldEmbed = opts?.embed ?? this.config.conversationIndexEmbedOnUpdate;
+    let embedded = false;
+    let rebuilt = false;
+    const backend = this.getBackend();
+    if (backend) {
+      const result = await backend.rebuild(chunks, {
+        embed: shouldEmbed
+      });
+      embedded = result.embedded;
+      rebuilt = result.rebuilt;
+    }
+    const stamp = Date.now();
+    if (sessionKey) {
+      this.lastUpdateAtMs.set(sessionKey, stamp);
+    } else {
+      this.lastUpdateAtMs.set("__rebuild__", stamp);
+    }
+    return { chunks: chunks.length, skipped: false, embedded, rebuilt };
+  }
+};
+
+// src/orchestration/recall-rerank-coordinator.ts
+var RecallRerankCoordinator = class _RecallRerankCoordinator {
+  getConfig;
+  getStorage;
+  readQmdResultMemory;
+  memoryWorthCounterCache = /* @__PURE__ */ new Map();
+  static MEMORY_WORTH_CACHE_TTL_MS = 3e4;
+  trustSignalCache = /* @__PURE__ */ new Map();
+  static TRUST_SIGNAL_CACHE_TTL_MS = 3e4;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.getStorage = options.getStorage;
+    this.readQmdResultMemory = options.readQmdResultMemory;
+  }
+  async applyMemoryWorthRerank(results, namespaces) {
+    const counters = /* @__PURE__ */ new Map();
+    const seenNamespaces = /* @__PURE__ */ new Set();
+    const nowMs = Date.now();
+    for (const [key, entry] of this.memoryWorthCounterCache) {
+      if (nowMs - entry.at >= _RecallRerankCoordinator.MEMORY_WORTH_CACHE_TTL_MS) {
+        this.memoryWorthCounterCache.delete(key);
+      }
+    }
+    for (const ns of namespaces) {
+      if (seenNamespaces.has(ns)) continue;
+      seenNamespaces.add(ns);
+      try {
+        const cached = this.memoryWorthCounterCache.get(ns);
+        let nsMap;
+        if (cached && nowMs - cached.at < _RecallRerankCoordinator.MEMORY_WORTH_CACHE_TTL_MS) {
+          nsMap = cached.counters;
+        } else {
+          const storage = await this.getStorage(ns);
+          const memories = await storage.readAllMemories();
+          nsMap = buildMemoryWorthCounterMap(memories);
+          this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
+        }
+        for (const [path6, c] of nsMap) counters.set(path6, c);
+      } catch (err) {
+        log.debug("memory-worth: failed to read namespace, skipping", {
+          namespace: ns,
+          error: err.message
+        });
+      }
+    }
+    const missing = results.filter((r) => !counters.has(r.path));
+    if (missing.length > 0) {
+      let reader = null;
+      for (const ns of namespaces) {
+        try {
+          reader = await this.getStorage(ns);
+          break;
+        } catch {
+        }
+      }
+      if (reader) {
+        for (const r of missing) {
+          try {
+            const memory = await this.readQmdResultMemory(r.path, reader, namespaces);
+            if (!memory) continue;
+            const fm = memory.frontmatter;
+            if (fm.mw_success === void 0 && fm.mw_fail === void 0) continue;
+            counters.set(r.path, {
+              mw_success: fm.mw_success,
+              mw_fail: fm.mw_fail,
+              lastAccessed: fm.lastAccessed
+            });
+          } catch (err) {
+            log.debug("memory-worth: direct path lookup failed", {
+              path: r.path,
+              error: err.message
+            });
+          }
+        }
+      }
+    }
+    if (counters.size === 0) return results;
+    const rankedInputs = results.map((r, i) => ({
+      path: r.path,
+      // Large positive rank score so multiplier math stays well-scaled and
+      // we never hit zero; descending so earlier items rank higher.
+      score: results.length - i
+    }));
+    const config = this.getConfig();
+    const filtered = applyMemoryWorthFilter(rankedInputs, {
+      counters,
+      now: /* @__PURE__ */ new Date(),
+      halfLifeMs: config.recallMemoryWorthHalfLifeMs > 0 ? config.recallMemoryWorthHalfLifeMs : void 0
+    });
+    const byPath = new Map(results.map((r) => [r.path, r]));
+    const reordered = [];
+    for (const item of filtered) {
+      const original = byPath.get(item.path);
+      if (original) reordered.push(original);
+    }
+    return reordered;
+  }
+  /**
+   * Issue #1577 — unified TrustScore recall stage. Thin wiring over the pure
+   * {@link applyTrustScoreStage} scorer + the {@link buildTrustSignalsForRerank}
+   * signal builder. The stage subsumes the Memory Worth multiplier — the
+   * orchestrator runs exactly one of the two (mutual exclusion, rule 39; the
+   * double-multiplier test in trust-score-stage.test.ts pins it structurally).
+   *
+   * Returns the admitted results AND the per-path trust map (including
+   * quarantined items) so the caller can: (a) render epistemic hedges, (b)
+   * surface quarantined items in X-ray with a reason (rule 34), and (c) filter
+   * quarantined paths from fallback recall branches. The trust map is a
+   * per-recall local — never instance state — so concurrent recalls cannot
+   * race on it (review: shared-trust-map concurrency).
+   */
+  async applyTrustScoreRerank(results, namespaces) {
+    if (results.length === 0) return { results, trustByPath: null };
+    const config = this.getConfig();
+    const now = /* @__PURE__ */ new Date();
+    const halfLifeDays = config.recallMemoryWorthHalfLifeMs > 0 ? config.recallMemoryWorthHalfLifeMs / (24 * 60 * 60 * 1e3) : void 0;
+    let fallbackReader = null;
+    const signals = await buildTrustSignalsForRerank(
+      results.map((r) => r.path),
+      namespaces,
+      {
+        readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
+        readMemoryFrontmatter: async (path6) => {
+          if (!fallbackReader) {
+            for (const ns of namespaces) {
+              try {
+                fallbackReader = await this.getStorage(ns);
+                break;
+              } catch {
+              }
+            }
+          }
+          if (!fallbackReader) return null;
+          const memory = await this.readQmdResultMemory(path6, fallbackReader, namespaces);
+          return memory ? memory.frontmatter : null;
+        }
+      },
+      { cache: this.trustSignalCache, ttlMs: _RecallRerankCoordinator.TRUST_SIGNAL_CACHE_TTL_MS },
+      now,
+      {
+        recencyHalfLifeDays: halfLifeDays,
+        logDebug: (message, context) => log.debug(message, context)
+      }
+    );
+    if (signals.size === 0) {
+      return { results, trustByPath: null };
+    }
+    const rankedInputs = results.map((r, i) => ({ path: r.path, score: results.length - i }));
+    const stage = applyTrustScoreStage(rankedInputs, {
+      signals,
+      weights: config.trustScoreWeights,
+      minMultiplier: config.trustScoreMinMultiplier,
+      maxMultiplier: config.trustScoreMaxMultiplier,
+      quarantine: config.trustScoreQuarantine
+    });
+    const trustByPath = new Map(stage.all.map((item) => [item.path, item]));
+    const byPath = new Map(results.map((r) => [r.path, r]));
+    const admitted = stage.admitted.map((item) => byPath.get(item.path)).filter((r) => r !== void 0);
+    return { results: admitted, trustByPath };
+  }
+  /**
+   * Issue #1577 — apply the TrustScore stage (or, when trust is off, the Memory
+   * Worth multiplier fallback) to ONE recall branch's results, returning the
+   * scored results + the per-path trust map. Thin wiring over
+   * {@link applyTrustScoreRerank} so every recall path — hot QMD, embedding
+   * fallback, recent scan — applies the SAME multiplier gate (rule 41: a
+   * feature gate must apply across ALL parallel recall paths). TrustScore
+   * subsumes Memory Worth; exactly one runs (rule 39). Fail-open on lookup
+   * errors so a storage hiccup never breaks a fallback path.
+   */
+  async applyTrustScoreToBranch(results, namespaces, caps, label) {
+    if (caps.recallTrustScore && results.length > 0) {
+      try {
+        return await this.applyTrustScoreRerank(results, namespaces);
+      } catch (err) {
+        log.debug(`trust-score stage (${label}) failed open`, {
+          error: err.message
+        });
+      }
+    } else if (caps.recallMemoryWorthFilter && results.length > 0) {
+      try {
+        const filtered = await this.applyMemoryWorthRerank(results, namespaces);
+        return { results: filtered, trustByPath: null };
+      } catch (err) {
+        log.debug(`memory-worth filter (${label}) failed open`, {
+          error: err.message
+        });
+      }
+    }
+    return { results, trustByPath: null };
+  }
+  diversifyAndLimitRecallResults(sectionId, results, limit, retrievalQuery, caps = resolveCapabilities(this.getConfig())) {
+    const safeLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
+    if (!Array.isArray(results) || results.length === 0) return [];
+    if (safeLimit === 0) return [];
+    const boosted = caps.recallReasoningTraceBoost && typeof retrievalQuery === "string" ? applyReasoningTraceBoost(results, {
+      enabled: true,
+      query: retrievalQuery
+    }) : results;
+    const diversified = this.applyMmrToQmdResults(sectionId, boosted, caps);
+    return diversified.slice(0, safeLimit);
+  }
+  /**
+   * Apply Maximal Marginal Relevance to a section's ordered candidate list.
+   *
+   * Operates per-section so one redundant cluster cannot dominate a section,
+   * and so one section's MMR pass cannot starve other sections. Returns the
+   * input unchanged when disabled, when there are fewer than 2 candidates, or
+   * when no budget information is available.
+   */
+  applyMmrToQmdResults(sectionId, results, caps = resolveCapabilities(this.getConfig())) {
+    if (!caps.recallMmr) return results;
+    if (!Array.isArray(results) || results.length < 2) return results;
+    const config = this.getConfig();
+    const configuredTopN = config.recallMmrTopN;
+    const topN = typeof configuredTopN === "number" && Number.isFinite(configuredTopN) ? Math.max(0, Math.floor(configuredTopN)) : 40;
+    if (topN === 0) return results;
+    const lambda = config.recallMmrLambda ?? 0.7;
+    const { reordered, diversity } = reorderRecallResultsWithMmr(results, {
+      lambda,
+      topN
+    });
+    try {
+      log.info(
+        `recall_mmr: section=${sectionId} kept=${diversity.kept}/${diversity.considered} headReorderCount=${diversity.headReorderCount} avgSimBefore=${diversity.avgPairwiseSimBefore.toFixed(3)} avgSimAfter=${diversity.avgPairwiseSimAfter.toFixed(3)} lambda=${lambda.toFixed(2)}`
+      );
+    } catch {
+    }
+    return reordered;
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -2275,7 +2721,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -2373,7 +2819,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path3.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path4.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile(taxonomyPath, "utf-8");
@@ -2423,16 +2869,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path3.join(memoryDir, TAXONOMY_DIR);
+  const dir = path4.join(memoryDir, TAXONOMY_DIR);
   await mkdir2(dir, { recursive: true });
-  const filePath = path3.join(dir, TAXONOMY_FILE);
+  const filePath = path4.join(dir, TAXONOMY_FILE);
   await writeFile2(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path3.join(memoryDir, TAXONOMY_DIR);
+  return path4.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path3.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path4.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/wearables/registry.ts
@@ -3333,7 +3779,7 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
   }
 }
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path4.isAbsolute(resultPath)) return null;
+  if (!resultPath || path5.isAbsolute(resultPath)) return null;
   const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
@@ -3346,9 +3792,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path4.resolve(storageDir);
+  const storageRoot = path5.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path4.resolve(candidate);
+    const resolved = path5.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -3356,12 +3802,12 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path4.join(storageRoot, normalized));
+    addCandidate(path5.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path4.join(storageRoot, "facts", normalized));
+      addCandidate(path5.join(storageRoot, "facts", normalized));
     }
   };
-  if (path4.isAbsolute(resultPath)) {
+  if (path5.isAbsolute(resultPath)) {
     addCandidate(resultPath);
   } else {
     addRelativeCandidates(resultPath);
@@ -3478,7 +3924,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path4.join(os2.homedir(), ".openclaw", "workspace");
+  return path5.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -3755,11 +4201,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path4.isAbsolute(candidatePath) ? candidatePath : path4.resolve(storageDir, candidatePath);
-  const rel = path4.relative(storageDir, absolutePath);
+  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(path4.sep).join("/");
+  return rel.split(path5.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -3904,7 +4350,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path4.relative(storageDir, mem.path));
+    pathById.set(id, path5.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -3912,7 +4358,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path4.join(options.storageDir, options.memoryRelPath),
+    path: path5.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -3932,16 +4378,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path4.join("corrections", `${options.memoryId}.md`);
+    return path5.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 path4.join(subtree, day, `${options.memoryId}.md`);
+    return path5.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path4.join(subtree, `${options.memoryId}.md`);
+  return path5.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -4048,25 +4494,6 @@ var Orchestrator = class _Orchestrator {
   /** Lossless Context Management engine — proactive session archive + DAG summarization. */
   lcmEngine = null;
   rerankCache = new RerankCache();
-  /**
-   * Short-TTL cache for Memory Worth counter lookups so interactive recall
-   * doesn't trigger a full `readAllMemories` scan per query. Keyed by
-   * namespace; the filter unions across namespaces at query time. The TTL
-   * is intentionally short (seconds, not minutes) because counters are
-   * mutated by `recordMemoryOutcome` asynchronously and we'd rather serve
-   * a 30-second-stale worth score than a stable-but-wrong one.
-   */
-  memoryWorthCounterCache = /* @__PURE__ */ new Map();
-  static MEMORY_WORTH_CACHE_TTL_MS = 3e4;
-  /**
-   * Issue #1577 — per-namespace TrustScore signal map cache. Same TTL/shape
-   * discipline as {@link memoryWorthCounterCache}: seconds-scale, evicted on
-   * every call, keyed by namespace. Holds the frontmatter-derived signals
-   * (worth, provenance, faithfulness, corroboration, recency) so the trust
-   * stage doesn't trigger a fresh `readAllMemories` scan per query.
-   */
-  trustSignalCache = /* @__PURE__ */ new Map();
-  static TRUST_SIGNAL_CACHE_TTL_MS = 3e4;
   /**
    * Per-session workspace selections keyed by sessionKey.
    * Set by the before_agent_start hook so recall() uses the correct
@@ -4116,13 +4543,18 @@ var Orchestrator = class _Orchestrator {
    * to RecallResultFormatter.
    */
   recallResultFormatter;
+  /**
+   * Issue #1526: conversation-index subsystem moved to
+   * ConversationIndexCoordinator.
+   */
+  conversationIndexCoordinator;
+  recallRerankCoordinator;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
   wearablesServiceInstance = null;
   wearablesAutoSyncHandle = null;
   lastQmdReprobeAtMs = 0;
-  conversationIndexLastUpdateAtMs = /* @__PURE__ */ new Map();
   lastFileHygieneRunAtMs = 0;
   // Pattern-reinforcement cadence gate (issue #687 PR 2/4).  Tracks the
   // last successful run so `runPatternReinforcement` can short-circuit
@@ -4409,7 +4841,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 = path4.resolve(storageDir);
+    const resolvedStorageDir = path5.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -4420,21 +4852,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path4.resolve(storageDir);
-    const resolvedMemoryDir = path4.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path5.resolve(storageDir);
+    const resolvedMemoryDir = path5.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path4.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path5.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path4.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path4.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path5.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path5.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path4.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path5.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path4.basename(resolvedStorageDir);
+    const leaf = path5.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -4462,7 +4894,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path4.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path5.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -4499,7 +4931,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path4.resolve(record.storageDir);
+      const resolvedStorageDir = path5.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -4763,7 +5195,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path4.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path5.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -4833,11 +5265,22 @@ 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 = path4.join(
+    this.conversationIndexDir = path5.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
     );
+    this.conversationIndexCoordinator = new ConversationIndexCoordinator({
+      config,
+      getTranscript: () => this.transcript,
+      getBackend: () => this.conversationIndexBackend,
+      indexDir: this.conversationIndexDir
+    });
+    this.recallRerankCoordinator = new RecallRerankCoordinator({
+      getConfig: () => this.config,
+      getStorage: (namespace) => this.getStorage(namespace),
+      readQmdResultMemory: (resultPath, fallbackStorage, recallNamespaces) => this.readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces)
+    });
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -4928,7 +5371,7 @@ var Orchestrator = class _Orchestrator {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path4.join(config.memoryDir, "threads"),
+      path5.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -5248,10 +5691,10 @@ var Orchestrator = class _Orchestrator {
       if (resolveRecallAuxiliaryCapabilities(this.config).compactionReset) {
         try {
           const wsDir = this.config.workspaceDir || defaultWorkspaceDir();
-          const files = await readdir(wsDir).catch(() => []);
+          const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path4.join(wsDir, f);
+            const fp = path5.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(() => {
@@ -5760,15 +6203,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path4.isAbsolute(rel) ? rel : path4.join(this.config.workspaceDir, rel);
+        const abs = path5.isAbsolute(rel) ? rel : path5.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path4.join(
+            const archiveDir = path5.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path4.basename(abs);
+            const base = path5.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -5793,8 +6236,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path4.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir3(path4.dirname(fp), { recursive: true });
+        const fp = path5.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir3(path5.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -5933,16 +6376,16 @@ ${doc.content}` : doc.content,
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path4.join(storage.dir, categoryDir, date);
+        const dateDir = path5.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
           assertPathInsideRoot(memoryRootReal, await realpath(dateDir), dateDir);
-          const entries = await readdir(dateDir, { withFileTypes: true });
+          const entries = await readdir2(dateDir, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path4.join(dateDir, entry.name);
+            const fullPath = path5.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile2(fullPath, "utf-8");
@@ -5964,7 +6407,7 @@ ${doc.content}` : doc.content,
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path4.basename(entry.name, ".md"),
+                  id: fm.id || path5.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -5987,13 +6430,13 @@ ${doc.content}` : doc.content,
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path4.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path5.join(storage.dir, "summaries", "hourly");
     try {
-      const sessionKeys = await readdir(hourlyBaseDir, { withFileTypes: true });
+      const sessionKeys = await readdir2(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path4.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path5.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -6097,7 +6540,7 @@ ${doc.content}` : doc.content,
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path4.join(
+    const snapshotPath = path5.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -6136,7 +6579,7 @@ ${doc.content}` : doc.content,
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path4.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path5.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -6169,7 +6612,7 @@ ${doc.content}` : doc.content,
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path4.join(
+    const snapshotPath = path5.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -6294,206 +6737,31 @@ ${doc.content}` : doc.content,
       })
     ].join("\n");
   }
-  async searchConversationRecallResults(retrievalQuery, topK) {
-    if (this.conversationIndexBackend) {
-      return this.conversationIndexBackend.search(retrievalQuery, topK);
-    }
-    return [];
-  }
-  formatConversationRecallSection(results, maxChars) {
-    if (!Array.isArray(results) || results.length === 0) return null;
-    const lines = ["## Semantic Recall (Past Conversations)", ""];
-    let used = 0;
-    for (const r of results) {
-      if (!r?.snippet) continue;
-      const chunk = `### ${r.path}
-Score: ${r.score.toFixed(3)}
-
-${r.snippet.trim()}
-`;
-      if (used + chunk.length > maxChars) break;
-      lines.push(chunk);
-      used += chunk.length;
-    }
-    return used > 0 ? lines.join("\n") : null;
-  }
-  async countConversationChunkDocs(dir) {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-      let total = 0;
-      for (const entry of entries) {
-        const fullPath = path4.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          total += await this.countConversationChunkDocs(fullPath);
-          continue;
-        }
-        if (entry.isFile() && entry.name.endsWith(".md")) {
-          total += 1;
-        }
-      }
-      return total;
-    } catch {
-      return 0;
-    }
-  }
-  async buildConversationIndexChunks(sessionKey, hours = 24) {
-    const entries = await this.transcript.readRecent(hours, sessionKey);
-    const effectiveSessionKey = sessionKey ?? "all-sessions";
-    return chunkTranscriptEntries(effectiveSessionKey, entries, {
-      maxChars: this.config.conversationRecallMaxChars * 2,
-      maxTurns: Math.max(10, this.config.hourlySummariesMaxTurnsPerRun)
-    });
-  }
-  async getConversationIndexHealth() {
-    const chunkDocCount = await this.countConversationChunkDocs(
-      this.conversationIndexDir
-    );
-    const lastUpdateAtMs = Math.max(
-      0,
-      ...this.conversationIndexLastUpdateAtMs.values()
-    );
-    const lastUpdateAt = lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return {
-        enabled: false,
-        backend: this.config.conversationIndexBackend,
-        status: "disabled",
-        chunkDocCount,
-        lastUpdateAt
-      };
-    }
-    const backendHealth = this.conversationIndexBackend ? await this.conversationIndexBackend.health() : {
-      backend: this.config.conversationIndexBackend,
-      status: "degraded"
-    };
-    return {
-      enabled: true,
-      chunkDocCount,
-      lastUpdateAt,
-      ...backendHealth
-    };
-  }
-  async inspectConversationIndex() {
-    const chunkDocCount = await this.countConversationChunkDocs(
-      this.conversationIndexDir
-    );
-    const lastUpdateAtMs = Math.max(
-      0,
-      ...this.conversationIndexLastUpdateAtMs.values()
-    );
-    const lastUpdateAt = lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return {
-        enabled: false,
-        backend: this.config.conversationIndexBackend,
-        status: "disabled",
-        available: false,
-        indexPath: this.conversationIndexDir,
-        supportsIncrementalUpdate: true,
-        message: "Conversation index disabled by config",
-        metadata: {
-          chunkCount: chunkDocCount
-        },
-        chunkDocCount,
-        lastUpdateAt
-      };
-    }
-    const inspection = this.conversationIndexBackend ? await this.conversationIndexBackend.inspect() : {
-      backend: this.config.conversationIndexBackend,
-      status: "degraded",
-      available: false,
-      indexPath: this.conversationIndexDir,
-      supportsIncrementalUpdate: true,
-      message: "Conversation index backend unavailable",
-      metadata: {
-        chunkCount: chunkDocCount
-      }
-    };
-    return {
-      enabled: true,
-      chunkDocCount,
-      lastUpdateAt,
-      ...inspection
-    };
+  async searchConversationRecallResults(retrievalQuery, topK) {
+    return this.conversationIndexCoordinator.search(retrievalQuery, topK);
+  }
+  formatConversationRecallSection(results, maxChars) {
+    return this.conversationIndexCoordinator.formatRecallSection(
+      results,
+      maxChars
+    );
+  }
+  // Issue #1526: countConversationChunkDocs / buildConversationIndexChunks moved
+  // to ConversationIndexCoordinator (internal helpers, no orchestrator callers).
+  async getConversationIndexHealth() {
+    return this.conversationIndexCoordinator.getHealth();
+  }
+  async inspectConversationIndex() {
+    return this.conversationIndexCoordinator.inspect();
   }
   async getRecoverySummary(sessionKey) {
     return this.transcript.getRecoverySummary(sessionKey);
   }
   async updateConversationIndex(sessionKey, hours = 24, opts) {
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return { chunks: 0, skipped: true, reason: "disabled", embedded: false };
-    }
-    const enforceMinInterval = opts?.enforceMinInterval !== false;
-    if (enforceMinInterval) {
-      const minIntervalMs = Math.max(
-        0,
-        this.config.conversationIndexMinUpdateIntervalMs
-      );
-      const now = Date.now();
-      const last = this.conversationIndexLastUpdateAtMs.get(sessionKey) ?? 0;
-      const elapsed = now - last;
-      if (minIntervalMs > 0 && elapsed < minIntervalMs) {
-        return {
-          chunks: 0,
-          skipped: true,
-          reason: "min_interval",
-          retryAfterMs: minIntervalMs - elapsed,
-          embedded: false
-        };
-      }
-    }
-    const chunks = await this.buildConversationIndexChunks(sessionKey, hours);
-    await writeConversationChunks(this.conversationIndexDir, chunks);
-    const retentionCutoffMs = Number.isFinite(this.config.conversationIndexRetentionDays) && this.config.conversationIndexRetentionDays > 0 ? Date.now() - this.config.conversationIndexRetentionDays * 24 * 60 * 60 * 1e3 : void 0;
-    await cleanupConversationChunks(
-      this.conversationIndexDir,
-      this.config.conversationIndexRetentionDays
-    );
-    const shouldEmbed = opts?.embed ?? this.config.conversationIndexEmbedOnUpdate;
-    let embedded = false;
-    if (this.conversationIndexBackend) {
-      const result = await this.conversationIndexBackend.update(chunks, {
-        embed: shouldEmbed,
-        ...retentionCutoffMs !== void 0 ? { retentionCutoffMs } : {}
-      });
-      embedded = result.embedded;
-    }
-    this.conversationIndexLastUpdateAtMs.set(sessionKey, Date.now());
-    return { chunks: chunks.length, skipped: false, embedded };
+    return this.conversationIndexCoordinator.update(sessionKey, hours, opts);
   }
   async rebuildConversationIndex(sessionKey, hours = 24, opts) {
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return {
-        chunks: 0,
-        skipped: true,
-        reason: "disabled",
-        embedded: false,
-        rebuilt: false
-      };
-    }
-    const chunks = await this.buildConversationIndexChunks(sessionKey, hours);
-    await writeConversationChunks(this.conversationIndexDir, chunks);
-    await cleanupConversationChunks(
-      this.conversationIndexDir,
-      this.config.conversationIndexRetentionDays
-    );
-    const shouldEmbed = opts?.embed ?? this.config.conversationIndexEmbedOnUpdate;
-    let embedded = false;
-    let rebuilt = false;
-    if (this.conversationIndexBackend) {
-      const result = await this.conversationIndexBackend.rebuild(chunks, {
-        embed: shouldEmbed
-      });
-      embedded = result.embedded;
-      rebuilt = result.rebuilt;
-    }
-    const stamp = Date.now();
-    if (sessionKey) {
-      this.conversationIndexLastUpdateAtMs.set(sessionKey, stamp);
-    } else {
-      this.conversationIndexLastUpdateAtMs.set("__rebuild__", stamp);
-    }
-    return { chunks: chunks.length, skipped: false, embedded, rebuilt };
+    return this.conversationIndexCoordinator.rebuild(sessionKey, hours, opts);
   }
   /**
    * Validate local LLM model availability and context window compatibility.
@@ -7228,7 +7496,7 @@ ${r.snippet.trim()}
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path4.isAbsolute(resolvedPath)) {
+      if (!path5.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -7253,7 +7521,7 @@ ${r.snippet.trim()}
         }
         continue;
       }
-      if (path4.isAbsolute(result.path)) {
+      if (path5.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -7296,7 +7564,7 @@ ${r.snippet.trim()}
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path4.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -7312,7 +7580,7 @@ ${r.snippet.trim()}
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path4.resolve(storage.dir, candidate.path);
+        const memoryPath = path5.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (deadlineExpired()) break;
         if (!memory) continue;
@@ -7337,7 +7605,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path4.resolve(storage.dir, candidate.seed),
+          seed: path5.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -7358,12 +7626,12 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path4.join(
+      const snapshotPath = path5.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -7397,12 +7665,12 @@ ${r.snippet.trim()}
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path4.join(
+      const snapshotPath = path5.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7414,12 +7682,12 @@ ${r.snippet.trim()}
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path4.join(
+      const snapshotPath = path5.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7434,8 +7702,8 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path4.join(stateDir, "last_intent.json");
-      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path5.join(stateDir, "last_intent.json");
+      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7447,12 +7715,12 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path4.join(this.config.memoryDir, "state");
+      return path5.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path4.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path5.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path4.join(
+    const candidate = path5.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -7460,11 +7728,11 @@ ${r.snippet.trim()}
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path4.join(candidate, "state");
+        return path5.join(candidate, "state");
       }
     } catch {
     }
-    return path4.join(this.config.memoryDir, "state");
+    return path5.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -7866,7 +8134,7 @@ ${r.snippet.trim()}
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path4.sep).join("/");
+        const normalizedPath = resultPath.split(path5.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -8016,7 +8284,7 @@ ${r.snippet.trim()}
         profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path4.join(this.config.memoryDir, ".empty-scope-profile") },
+        { dir: path5.join(this.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -9492,11 +9760,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path4.join(
+        const signalPath = path5.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path4.join(workspaceDir, "BOOT.md");
+        const bootPath = path5.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -14098,7 +14366,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path4.relative(storage.dir, m.path);
+            const rel = path5.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -14422,7 +14690,7 @@ ${normalized}`).digest("hex");
     }
     if (resolveConsolidationCapabilities(this.config).semanticConsolidation) {
       try {
-        const stateFilePath = path4.join(
+        const stateFilePath = path5.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -14470,7 +14738,7 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path4.join(this.config.memoryDir, "state");
+            const stateDir = path5.join(this.config.memoryDir, "state");
             await mkdir3(stateDir, { recursive: true });
             await writeFile3(
               stateFilePath,
@@ -14791,7 +15059,7 @@ ${reflectionsContent.trim()}
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirFor(storage);
-        const storageKey = storageDir ? path4.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path5.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -14821,7 +15089,7 @@ ${reflectionsContent.trim()}
           continue;
         }
         try {
-          const coldRoot = path4.join(storageDir, "cold");
+          const coldRoot = path5.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(
             coldRoot,
             parts.relativePath
@@ -14862,7 +15130,7 @@ ${reflectionsContent.trim()}
         return null;
       }
     }
-    if (path4.isAbsolute(resultPath)) {
+    if (path5.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -14901,7 +15169,7 @@ ${reflectionsContent.trim()}
     );
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path4.isAbsolute(memory.path)) {
+    if (path5.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(
         memory.path,
         fallbackStorage,
@@ -14925,16 +15193,16 @@ ${reflectionsContent.trim()}
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path4.resolve(resultPath);
-    const memoryRoot = path4.resolve(this.config.memoryDir);
-    const namespacesRoot = path4.join(memoryRoot, "namespaces");
+    const resolvedPath = path5.resolve(resultPath);
+    const memoryRoot = path5.resolve(this.config.memoryDir);
+    const namespacesRoot = path5.join(memoryRoot, "namespaces");
     const fallbackStorageDir = typeof fallbackStorage.dir === "string" && fallbackStorage.dir ? fallbackStorage.dir : null;
     const matches = [];
     const seenDirs = /* @__PURE__ */ new Set();
     const maybeAddStorage = (storage, namespace) => {
       const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
       if (!storageDir) return;
-      const candidateRoot = path4.resolve(storageDir);
+      const candidateRoot = path5.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -14952,7 +15220,7 @@ ${reflectionsContent.trim()}
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path4.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path5.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(
@@ -14974,218 +15242,22 @@ ${reflectionsContent.trim()}
     matches.sort((a, b) => b.dir.length - a.dir.length);
     return matches[0] ?? null;
   }
+  // Issue #1526: recall-rerank methods moved to RecallRerankCoordinator.
+  // Thin delegation keeps the private API stable for callers + tests.
   async applyMemoryWorthRerank(results, namespaces) {
-    const counters = /* @__PURE__ */ new Map();
-    const seenNamespaces = /* @__PURE__ */ new Set();
-    const nowMs = Date.now();
-    for (const [key, entry] of this.memoryWorthCounterCache) {
-      if (nowMs - entry.at >= _Orchestrator.MEMORY_WORTH_CACHE_TTL_MS) {
-        this.memoryWorthCounterCache.delete(key);
-      }
-    }
-    for (const ns of namespaces) {
-      if (seenNamespaces.has(ns)) continue;
-      seenNamespaces.add(ns);
-      try {
-        const cached = this.memoryWorthCounterCache.get(ns);
-        let nsMap;
-        if (cached && nowMs - cached.at < _Orchestrator.MEMORY_WORTH_CACHE_TTL_MS) {
-          nsMap = cached.counters;
-        } else {
-          const storage = await this.getStorage(ns);
-          const memories = await storage.readAllMemories();
-          nsMap = buildMemoryWorthCounterMap(memories);
-          this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
-        }
-        for (const [path5, c] of nsMap) counters.set(path5, c);
-      } catch (err) {
-        log.debug("memory-worth: failed to read namespace, skipping", {
-          namespace: ns,
-          error: err.message
-        });
-      }
-    }
-    const missing = results.filter((r) => !counters.has(r.path));
-    if (missing.length > 0) {
-      let reader = null;
-      for (const ns of namespaces) {
-        try {
-          reader = await this.getStorage(ns);
-          break;
-        } catch {
-        }
-      }
-      if (reader) {
-        for (const r of missing) {
-          try {
-            const memory = await this.readQmdResultMemory(r.path, reader, namespaces);
-            if (!memory) continue;
-            const fm = memory.frontmatter;
-            if (fm.mw_success === void 0 && fm.mw_fail === void 0) continue;
-            counters.set(r.path, {
-              mw_success: fm.mw_success,
-              mw_fail: fm.mw_fail,
-              lastAccessed: fm.lastAccessed
-            });
-          } catch (err) {
-            log.debug("memory-worth: direct path lookup failed", {
-              path: r.path,
-              error: err.message
-            });
-          }
-        }
-      }
-    }
-    if (counters.size === 0) return results;
-    const rankedInputs = results.map((r, i) => ({
-      path: r.path,
-      // Large positive rank score so multiplier math stays well-scaled and
-      // we never hit zero; descending so earlier items rank higher.
-      score: results.length - i
-    }));
-    const filtered = applyMemoryWorthFilter(rankedInputs, {
-      counters,
-      now: /* @__PURE__ */ new Date(),
-      halfLifeMs: this.config.recallMemoryWorthHalfLifeMs > 0 ? this.config.recallMemoryWorthHalfLifeMs : void 0
-    });
-    const byPath = new Map(results.map((r) => [r.path, r]));
-    const reordered = [];
-    for (const item of filtered) {
-      const original = byPath.get(item.path);
-      if (original) reordered.push(original);
-    }
-    return reordered;
+    return this.recallRerankCoordinator.applyMemoryWorthRerank(results, namespaces);
   }
-  /**
-   * Issue #1577 — unified TrustScore recall stage. Thin wiring over the pure
-   * {@link applyTrustScoreStage} scorer + the {@link buildTrustSignalsForRerank}
-   * signal builder. The stage subsumes the Memory Worth multiplier — the
-   * orchestrator runs exactly one of the two (mutual exclusion, rule 39; the
-   * double-multiplier test in trust-score-stage.test.ts pins it structurally).
-   *
-   * Returns the admitted results AND the per-path trust map (including
-   * quarantined items) so the caller can: (a) render epistemic hedges, (b)
-   * surface quarantined items in X-ray with a reason (rule 34), and (c) filter
-   * quarantined paths from fallback recall branches. The trust map is a
-   * per-recall local — never instance state — so concurrent recalls cannot
-   * race on it (review: shared-trust-map concurrency).
-   */
   async applyTrustScoreRerank(results, namespaces) {
-    if (results.length === 0) return { results, trustByPath: null };
-    const now = /* @__PURE__ */ new Date();
-    const halfLifeDays = this.config.recallMemoryWorthHalfLifeMs > 0 ? this.config.recallMemoryWorthHalfLifeMs / (24 * 60 * 60 * 1e3) : void 0;
-    let fallbackReader = null;
-    const signals = await buildTrustSignalsForRerank(
-      results.map((r) => r.path),
-      namespaces,
-      {
-        readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path5) => {
-          if (!fallbackReader) {
-            for (const ns of namespaces) {
-              try {
-                fallbackReader = await this.getStorage(ns);
-                break;
-              } catch {
-              }
-            }
-          }
-          if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path5, fallbackReader, namespaces);
-          return memory ? memory.frontmatter : null;
-        }
-      },
-      { cache: this.trustSignalCache, ttlMs: _Orchestrator.TRUST_SIGNAL_CACHE_TTL_MS },
-      now,
-      {
-        recencyHalfLifeDays: halfLifeDays,
-        logDebug: (message, context) => log.debug(message, context)
-      }
-    );
-    if (signals.size === 0) {
-      return { results, trustByPath: null };
-    }
-    const rankedInputs = results.map((r, i) => ({ path: r.path, score: results.length - i }));
-    const stage = applyTrustScoreStage(rankedInputs, {
-      signals,
-      weights: this.config.trustScoreWeights,
-      minMultiplier: this.config.trustScoreMinMultiplier,
-      maxMultiplier: this.config.trustScoreMaxMultiplier,
-      quarantine: this.config.trustScoreQuarantine
-    });
-    const trustByPath = new Map(stage.all.map((item) => [item.path, item]));
-    const byPath = new Map(results.map((r) => [r.path, r]));
-    const admitted = stage.admitted.map((item) => byPath.get(item.path)).filter((r) => r !== void 0);
-    return { results: admitted, trustByPath };
+    return this.recallRerankCoordinator.applyTrustScoreRerank(results, namespaces);
   }
-  /**
-   * Issue #1577 — apply the TrustScore stage (or, when trust is off, the Memory
-   * Worth multiplier fallback) to ONE recall branch's results, returning the
-   * scored results + the per-path trust map. Thin wiring over
-   * {@link applyTrustScoreRerank} so every recall path — hot QMD, embedding
-   * fallback, recent scan — applies the SAME multiplier gate (rule 41: a
-   * feature gate must apply across ALL parallel recall paths). TrustScore
-   * subsumes Memory Worth; exactly one runs (rule 39). Fail-open on lookup
-   * errors so a storage hiccup never breaks a fallback path.
-   */
   async applyTrustScoreToBranch(results, namespaces, caps, label) {
-    if (caps.recallTrustScore && results.length > 0) {
-      try {
-        return await this.applyTrustScoreRerank(results, namespaces);
-      } catch (err) {
-        log.debug(`trust-score stage (${label}) failed open`, {
-          error: err.message
-        });
-      }
-    } else if (caps.recallMemoryWorthFilter && results.length > 0) {
-      try {
-        const filtered = await this.applyMemoryWorthRerank(results, namespaces);
-        return { results: filtered, trustByPath: null };
-      } catch (err) {
-        log.debug(`memory-worth filter (${label}) failed open`, {
-          error: err.message
-        });
-      }
-    }
-    return { results, trustByPath: null };
+    return this.recallRerankCoordinator.applyTrustScoreToBranch(results, namespaces, caps, label);
   }
   diversifyAndLimitRecallResults(sectionId, results, limit, retrievalQuery, caps = resolveCapabilities(this.config)) {
-    const safeLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
-    if (!Array.isArray(results) || results.length === 0) return [];
-    if (safeLimit === 0) return [];
-    const boosted = caps.recallReasoningTraceBoost && typeof retrievalQuery === "string" ? applyReasoningTraceBoost(results, {
-      enabled: true,
-      query: retrievalQuery
-    }) : results;
-    const diversified = this.applyMmrToQmdResults(sectionId, boosted, caps);
-    return diversified.slice(0, safeLimit);
+    return this.recallRerankCoordinator.diversifyAndLimitRecallResults(sectionId, results, limit, retrievalQuery, caps);
   }
-  /**
-   * Apply Maximal Marginal Relevance to a section's ordered candidate list.
-   *
-   * Operates per-section so one redundant cluster cannot dominate a section,
-   * and so one section's MMR pass cannot starve other sections. Returns the
-   * input unchanged when disabled, when there are fewer than 2 candidates, or
-   * when no budget information is available.
-   */
   applyMmrToQmdResults(sectionId, results, caps = resolveCapabilities(this.config)) {
-    if (!caps.recallMmr) return results;
-    if (!Array.isArray(results) || results.length < 2) return results;
-    const configuredTopN = this.config.recallMmrTopN;
-    const topN = typeof configuredTopN === "number" && Number.isFinite(configuredTopN) ? Math.max(0, Math.floor(configuredTopN)) : 40;
-    if (topN === 0) return results;
-    const lambda = this.config.recallMmrLambda ?? 0.7;
-    const { reordered, diversity } = reorderRecallResultsWithMmr(results, {
-      lambda,
-      topN
-    });
-    try {
-      log.info(
-        `recall_mmr: section=${sectionId} kept=${diversity.kept}/${diversity.considered} headReorderCount=${diversity.headReorderCount} avgSimBefore=${diversity.avgPairwiseSimBefore.toFixed(3)} avgSimAfter=${diversity.avgPairwiseSimAfter.toFixed(3)} lambda=${lambda.toFixed(2)}`
-      );
-    } catch {
-    }
-    return reordered;
+    return this.recallRerankCoordinator.applyMmrToQmdResults(sectionId, results, caps);
   }
   buildLastRecallBudgetSummary(options) {
     return {
@@ -15261,12 +15333,12 @@ ${reflectionsContent.trim()}
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path4.resolve(this.config.memoryDir);
-    const storageDir = path4.resolve(targetStorage.dir);
+    const memoryDir = path5.resolve(this.config.memoryDir);
+    const storageDir = path5.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path4.relative(memoryDir, storageDir);
+    let rel = path5.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`
@@ -15285,7 +15357,7 @@ ${reflectionsContent.trim()}
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path4.isAbsolute(hit.path) ? hit.path : path4.join(this.config.memoryDir, hit.path);
+      const fullPath = path5.isAbsolute(hit.path) ? hit.path : path5.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -15482,7 +15554,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 = path4.resolve(storageDir);
+          const recallRoot = path5.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -15506,8 +15578,8 @@ ${reflectionsContent.trim()}
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path4.isAbsolute(result.path)) {
-          const resolvedPath = path4.resolve(result.path);
+        if (path5.isAbsolute(result.path)) {
+          const resolvedPath = path5.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -16441,4 +16513,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-EKQ3LWBM.js.map
+//# sourceMappingURL=chunk-IEWUPZ75.js.map