@remnic/core 9.3.738 → 9.3.740

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

@@ -7,10 +7,10 @@ import {
 } from "./chunk-OZECYVGI.js";
 import {
   CompressionGuidelineCoordinator
-} from "./chunk-QTJOORGN.js";
+} from "./chunk-WIMKOTNY.js";
 import {
   MaintenanceScheduler
-} from "./chunk-YF2MMBKA.js";
+} from "./chunk-BJPL5WAL.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -29,10 +29,10 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-75PDC7VT.js";
+} from "./chunk-UOVDO6TC.js";
 import {
   SharedContextManager
-} from "./chunk-UFS7OXGL.js";
+} from "./chunk-WHEF76BQ.js";
 import {
   applyTrustScoreStage,
   buildTrustSignalsForRerank,
@@ -63,7 +63,7 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-BVG2IZOB.js";
+} from "./chunk-USHVHI6J.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -160,7 +160,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-XIQAOGAA.js";
+} from "./chunk-WGDE2TJP.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -169,7 +169,7 @@ import {
 } from "./chunk-PWFWCGOO.js";
 import {
   LocalLlmClient
-} from "./chunk-YXOXAQ5Y.js";
+} from "./chunk-TQQN64J2.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -187,18 +187,18 @@ import {
 } from "./chunk-4463LUIE.js";
 import {
   formatDaySummaryMemories
-} from "./chunk-EO5QWINU.js";
+} from "./chunk-C3Z5YJSM.js";
 import {
   tryDirectAnswer
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-WVAEIKUY.js";
+} from "./chunk-GPX5E36D.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-CKHPUOAP.js";
+} from "./chunk-K2N6WIZM.js";
 import {
   RoutingRulesStore
 } from "./chunk-WIWPSQYU.js";
@@ -208,14 +208,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-WDJCZQB4.js";
+} from "./chunk-UGFPGWJB.js";
 import {
   ThreadingManager
 } from "./chunk-QRDOSYOR.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-IQOEW5YV.js";
+} from "./chunk-FCQ7ZYCQ.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -228,14 +228,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-TNLXCSXV.js";
+} from "./chunk-O4IWVWSW.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-BHQQVUEQ.js";
+} from "./chunk-X5PMDVY4.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-VRBBZH4U.js";
+} from "./chunk-AX4TRSRE.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -270,7 +270,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-5RZOFIDL.js";
+} from "./chunk-PI4JHLDD.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -292,7 +292,7 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   SmartBuffer
-} from "./chunk-OQQRWPFZ.js";
+} from "./chunk-OS5RKJOH.js";
 import {
   isDisagreementPrompt
 } from "./chunk-H3FZVNRN.js";
@@ -311,7 +311,7 @@ import {
   clusterByKey,
   createCorrectionService,
   detectPassiveCorrections
-} from "./chunk-WFNH4UDF.js";
+} from "./chunk-Y6PNYJVO.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -333,14 +333,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-7B7IPPN5.js";
+} from "./chunk-OVYBENIJ.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-66RZ4EIT.js";
+} from "./chunk-BE6NEQLF.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-JQSP7YBJ.js";
+} from "./chunk-ELL5VYXC.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -363,7 +363,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-C53JDEH3.js";
+} from "./chunk-Y62QPRKV.js";
 import {
   searchCausalTrajectories
 } from "./chunk-SQNED75R.js";
@@ -376,7 +376,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-F6OEXJQQ.js";
+} from "./chunk-6XG3NQRC.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -384,7 +384,7 @@ import {
   fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
   parseEntityFile
-} from "./chunk-Q6BAA57B.js";
+} from "./chunk-JFCS6PQU.js";
 import {
   buildRetiredFactTombstoneInputs
 } from "./chunk-L2B3EE7B.js";
@@ -465,7 +465,7 @@ import {
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-DS3FZ7GS.js";
+} from "./chunk-OUSOMUFV.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule
@@ -474,6 +474,7 @@ import {
   resolveCapabilities,
   resolveCompressionCapabilities,
   resolveConsolidationCapabilities,
+  resolveConversationContextCapabilities,
   resolveCreationMemoryCapabilities,
   resolveEvalCapabilities,
   resolveGraphConstructionCapabilities,
@@ -483,12 +484,14 @@ import {
   resolveMemoryLifecycleCapabilities,
   resolveNamespaceCapabilities,
   resolveObjectiveStateCapabilities,
+  resolvePipelineProcessingCapabilities,
   resolvePresentationCapabilities,
   resolveQmdCapabilities,
   resolveRecallAuxiliaryCapabilities,
+  resolveRecallEnhancementCapabilities,
   resolveSecurityCapabilities,
   resolveUtilityLearningCapabilities
-} from "./chunk-RJBW4EOU.js";
+} from "./chunk-G7Q4D2G3.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -509,14 +512,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,
@@ -960,7 +963,7 @@ var SemanticConsolidationCoordinator = class {
     for (const cluster of clusters) {
       let canonicalWriteCompleted = false;
       try {
-        const operatorAwareEnabled = this.config.operatorAwareConsolidationEnabled === true;
+        const operatorAwareEnabled = resolveConversationContextCapabilities(this.config).operatorAwareConsolidation === true;
         let prompt = operatorAwareEnabled ? buildOperatorAwareConsolidationPrompt(cluster) : buildConsolidationPrompt(cluster);
         if (extensionsBlock.length > 0) {
           prompt += "\n\n" + extensionsBlock;
@@ -1106,7 +1109,7 @@ var SemanticConsolidationCoordinator = class {
         `[semantic-consolidation] Codex materialize post-hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    if (this.config.peerProfileReasonerEnabled) {
+    if (resolveConversationContextCapabilities(this.config).peerProfileReasoner) {
       try {
         const peerLlm = new FallbackLlmClient(
           this.config.gatewayConfig,
@@ -1942,6 +1945,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 +2724,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 +2822,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 +2872,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 +3782,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 +3795,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 +3805,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 +3927,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 +4204,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 +4353,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 +4361,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 +4381,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 +4497,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 +4546,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 +4844,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 +4855,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 +4897,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 +4934,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,
@@ -4762,8 +5197,8 @@ var Orchestrator = class _Orchestrator {
   constructor(config) {
     this.config = config;
     this.profiler = new ProfilingCollector({
-      enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path4.join(config.memoryDir, "profiling"),
+      enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
+      storageDir: config.profilingStorageDir || path5.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -4829,15 +5264,26 @@ var Orchestrator = class _Orchestrator {
     this.conversationQmd = conversationIndexRuntime.qmd;
     this.conversationFaiss = conversationIndexRuntime.faiss;
     this.conversationIndexBackend = conversationIndexRuntime.backend;
-    this.sharedContext = config.sharedContextEnabled ? new SharedContextManager(config) : void 0;
+    this.sharedContext = resolveConversationContextCapabilities(this.config).sharedContext ? new SharedContextManager(config) : void 0;
     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);
@@ -4881,7 +5327,7 @@ var Orchestrator = class _Orchestrator {
     this.judgeDeferCounts = createDeferCountMap();
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
     this.localLlm.disableThinking = config.localLlmDisableThinking;
-    this.fastLlm = config.localLlmFastEnabled ? (() => {
+    this.fastLlm = resolvePipelineProcessingCapabilities(this.config).localLlmFast ? (() => {
       const client = new LocalLlmClient(
         {
           ...config,
@@ -4928,7 +5374,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);
@@ -4937,7 +5383,7 @@ var Orchestrator = class _Orchestrator {
       tmtHourlyMinMemories: config.tmtHourlyMinMemories,
       tmtSummaryMaxTokens: config.tmtSummaryMaxTokens
     });
-    if (config.lcmEnabled) {
+    if (resolvePipelineProcessingCapabilities(this.config).lcm) {
       const summarizeFn = async (text, targetTokens, aggressive) => {
         const instructionText = aggressive ? `Compress the following into bullet points. One bullet per distinct fact or decision. Maximum ${targetTokens} tokens total. No prose.` : `Compress the following conversation segment into a dense summary. Preserve: decisions made, code artifacts mentioned, errors encountered, open questions, and any commitments or next-steps. Omit: pleasantries, restatements, and anything the agent would not need to recall later. Output a single paragraph, maximum ${targetTokens} tokens.`;
         try {
@@ -4976,7 +5422,7 @@ var Orchestrator = class _Orchestrator {
         dir,
         new BoxBuilder(dir, {
           memoryBoxesEnabled: resolvePresentationCapabilities(this.config).memoryBoxes,
-          traceWeaverEnabled: this.config.traceWeaverEnabled,
+          traceWeaverEnabled: resolvePipelineProcessingCapabilities(this.config).traceWeaver,
           boxTopicShiftThreshold: this.config.boxTopicShiftThreshold,
           boxTimeGapMs: this.config.boxTimeGapMs,
           boxMaxMemories: this.config.boxMaxMemories,
@@ -5042,7 +5488,7 @@ var Orchestrator = class _Orchestrator {
     return this.routingRulesStore;
   }
   async loadRoutingRules() {
-    if (!this.config.routingRulesEnabled) return [];
+    if (!resolvePipelineProcessingCapabilities(this.config).routingRules) return [];
     try {
       return await this.getRoutingRulesStore().read(this.routeEngineOptions());
     } catch (err) {
@@ -5248,10 +5694,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(() => {
@@ -5446,7 +5892,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-5DXD3TF2.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-GQ3UQNIL.js");
         const result = await runFirstStartMigration({
           storage: this.storage,
           config: this.config,
@@ -5760,15 +6206,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 +6239,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 +6379,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 +6410,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 +6433,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 +6543,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 +6582,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 +6615,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 +6740,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 +7499,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 +7524,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 +7567,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 +7583,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 +7608,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 +7629,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 +7668,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 +7685,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 +7705,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 +7718,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 +7731,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) => ({
@@ -7765,7 +8036,7 @@ ${r.snippet.trim()}
         caps,
         signal: options.abortSignal
       });
-      if (this.config.recallPlannerTelemetryEnabled && recallDecision.plannerSource && recallDecision.plannerSource !== "heuristic") {
+      if (resolveRecallEnhancementCapabilities(this.config).recallPlannerTelemetry && recallDecision.plannerSource && recallDecision.plannerSource !== "heuristic") {
         log.debug(
           `[recall-planner] mode=${recallDecision.shadowLlmMode ?? recallDecision.effectiveMode} source=${recallDecision.plannerSource} planned=${recallDecision.plannedMode} heuristic=${recallDecision.plannerHeuristicMode ?? recallDecision.plannedMode} model=${recallDecision.plannerModelUsed ?? "n/a"} latencyMs=${recallDecision.plannerLatencyMs ?? 0} fallback=${recallDecision.plannerFallbackUsed ?? false}` + (recallDecision.shadowLlmMode ? " (shadow)" : "")
         );
@@ -7866,7 +8137,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 +8287,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];
@@ -8156,7 +8427,7 @@ ${r.snippet.trim()}
       const sharedContextPromise = (async () => {
         if (!this.isRecallSectionEnabled(
           "shared-context",
-          this.config.sharedContextEnabled === true
+          resolveConversationContextCapabilities(this.config).sharedContext === true
         ))
           return null;
         if (!this.sharedContext) return null;
@@ -8234,7 +8505,7 @@ ${trimmedBody}`;
       })();
       let peerProfileXrayAnnotation = void 0;
       const peerProfileRecallPromise = (async () => {
-        if (!this.config.peerProfileRecallEnabled) return null;
+        if (!resolveRecallEnhancementCapabilities(this.config).peerProfileRecall) return null;
         if (this.config.peerProfileRecallMaxFields <= 0) return null;
         const peerId = this.getPeerIdForSession(sessionKey);
         if (!peerId) return null;
@@ -8559,9 +8830,9 @@ ${rows.join("\n")}
       })();
       const causalTrajectoryPromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.causalTrajectoryMemoryEnabled || !this.config.causalTrajectoryRecallEnabled || !this.isRecallSectionEnabled(
+        if (!resolveRecallEnhancementCapabilities(this.config).causalTrajectoryMemory || !resolveRecallEnhancementCapabilities(this.config).causalTrajectoryRecall || !this.isRecallSectionEnabled(
           "causal-trajectories",
-          this.config.causalTrajectoryRecallEnabled === true
+          resolveRecallEnhancementCapabilities(this.config).causalTrajectoryRecall === true
         )) {
           recordRecallSectionMetric({
             section: "causalTrajectories",
@@ -8606,9 +8877,9 @@ ${rows.join("\n")}
       })();
       const cmcRetrievalPromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.cmcRetrievalEnabled || !this.isRecallSectionEnabled(
+        if (!resolveRecallEnhancementCapabilities(this.config).cmcRetrieval || !this.isRecallSectionEnabled(
           "cmc-causal-chains",
-          this.config.cmcRetrievalEnabled === true
+          resolveRecallEnhancementCapabilities(this.config).cmcRetrieval === true
         )) {
           recordRecallSectionMetric({
             section: "cmcCausalChains",
@@ -9436,7 +9707,7 @@ ${rows.join("\n")}
         }
         let section = null;
         let checkpointInjected = false;
-        if (this.config.checkpointEnabled) {
+        if (resolvePipelineProcessingCapabilities(this.config).checkpoint) {
           const checkpoint = await this.transcript.loadCheckpoint(sessionKey);
           log.debug(
             `recall: checkpoint loaded, turns=${checkpoint?.turns?.length ?? 0}`
@@ -9492,11 +9763,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;
@@ -9544,7 +9815,7 @@ ${formatted}`;
       })();
       const summariesPromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.hourlySummariesEnabled || !sessionKey || !this.isRecallSectionEnabled("summaries", true)) {
+        if (!resolvePipelineProcessingCapabilities(this.config).hourlySummaries || !sessionKey || !this.isRecallSectionEnabled("summaries", true)) {
           recordRecallSectionMetric({
             section: "summaries",
             priority: "core",
@@ -9729,7 +10000,7 @@ ${formatted}`;
       const compoundingPromise = observeEnrichmentPromise(
         (async () => {
           const t0 = Date.now();
-          if (!this.compounding || !this.config.compoundingInjectEnabled || !this.isRecallSectionEnabled("compounding", true)) {
+          if (!this.compounding || !resolveRecallEnhancementCapabilities(this.config).compoundingInject || !this.isRecallSectionEnabled("compounding", true)) {
             recordRecallSectionMetric({
               section: "compounding",
               priority: "enrichment",
@@ -9970,7 +10241,7 @@ ${formatted}`;
       if (sharedCtx)
         this.appendRecallSection(sectionBuckets, "shared-context", sharedCtx);
       const explicitCueMaxChars = this.getRecallSectionMaxChars("explicit-cue") ?? this.config.explicitCueRecallMaxChars;
-      if (this.config.explicitCueRecallEnabled && this.isRecallSectionEnabled("explicit-cue") && explicitCueMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall") {
+      if (resolveRecallEnhancementCapabilities(this.config).explicitCueRecall && this.isRecallSectionEnabled("explicit-cue") && explicitCueMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall") {
         try {
           const explicitCueSection = await buildExplicitCueRecallSection({
             engine: this.lcmEngine,
@@ -9999,7 +10270,7 @@ ${formatted}`;
       const targetedFactMaxChars = this.getRecallSectionMaxChars("targeted-facts") ?? this.config.targetedFactRecallMaxChars;
       if (this.isSpecializedRecallSectionEnabled(
         "targeted-facts",
-        this.config.targetedFactRecallEnabled
+        resolveRecallEnhancementCapabilities(this.config).targetedFactRecall
       ) && targetedFactMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && shouldRecallTargetedFactEvidence(retrievalQuery)) {
         try {
           const targetedFactSection = await buildTargetedFactRecallSection({
@@ -10029,7 +10300,7 @@ ${formatted}`;
       const focusedListMaxChars = this.getRecallSectionMaxChars("focused-list") ?? this.config.focusedListRecallMaxChars;
       if (this.isSpecializedRecallSectionEnabled(
         "focused-list",
-        this.config.focusedListRecallEnabled
+        resolveRecallEnhancementCapabilities(this.config).focusedListRecall
       ) && focusedListMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && shouldRecallFocusedListEvidence(retrievalQuery)) {
         try {
           const focusedListSection = await buildFocusedListRecallSection({
@@ -10063,7 +10334,7 @@ ${formatted}`;
       const responseGuidanceForcedByPipeline = responseGuidanceEntry?.forceGeneric === true && !responseGuidanceMatchesQuery;
       if (this.isSpecializedRecallSectionEnabled(
         "response-guidance",
-        this.config.responseGuidanceRecallEnabled
+        resolveRecallEnhancementCapabilities(this.config).responseGuidanceRecall
       ) && responseGuidanceMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && (responseGuidanceMatchesQuery || responseGuidanceForcedByPipeline)) {
         try {
           const responseGuidanceSection = await buildResponseGuidanceRecallSection({
@@ -10095,7 +10366,7 @@ ${formatted}`;
       const eventOrderMaxChars = this.getRecallSectionMaxChars("event-order") ?? this.config.eventOrderRecallMaxChars;
       if (this.isSpecializedRecallSectionEnabled(
         "event-order",
-        this.config.eventOrderRecallEnabled
+        resolveRecallEnhancementCapabilities(this.config).eventOrderRecall
       ) && eventOrderMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall" && shouldRecallEventOrderEvidence(retrievalQuery)) {
         try {
           const eventOrderSection = await firstNonEmptyLcmRead(
@@ -10388,7 +10659,7 @@ ${tmtNode.summary}`
         );
         const isFullModeGraphAssist = graphCaps.multiGraphMemory && caps.graphAssistInFullMode && recallMode === "full" && memoryResults.length >= Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
         const shouldRunGraphExpansion = recallMode === "graph_mode" || isFullModeGraphAssist;
-        const graphShadowEvalEnabled = isFullModeGraphAssist && this.config.graphAssistShadowEvalEnabled === true;
+        const graphShadowEvalEnabled = isFullModeGraphAssist && resolveRecallEnhancementCapabilities(this.config).graphAssistShadowEval === true;
         if (shouldRunGraphExpansion) {
           shouldPersistGraphSnapshot = true;
           graphDecisionShadowMode = graphShadowEvalEnabled;
@@ -10583,7 +10854,7 @@ ${tmtNode.summary}`
           retrievalQuery,
           caps
         );
-        if (this.config.memoryReconstructionEnabled && memoryResults.length > 0) {
+        if (resolveRecallEnhancementCapabilities(this.config).memoryReconstruction && memoryResults.length > 0) {
           try {
             const snippets = memoryResults.map((r) => r.snippet);
             const coveredRefs = memoryResults.map((r) => r.path).filter((p) => p.startsWith("entities/")).map((p) => p.replace(/^entities\//, "").replace(/\.md$/, ""));
@@ -11888,7 +12159,7 @@ _Context: ${topQuestion.context}_`
     return ingestResult;
   }
   async observeSessionHeartbeat(sessionKey, options = {}) {
-    if (this.config.sessionObserverEnabled !== true) return;
+    if (resolvePipelineProcessingCapabilities(this.config).sessionObserver !== true) return;
     if (!sessionKey || sessionKey.length === 0) return;
     const bufferKey = typeof options.bufferKey === "string" && options.bufferKey.length > 0 ? options.bufferKey : sessionKey;
     const previous = this.heartbeatObserverChains.get(sessionKey) ?? Promise.resolve();
@@ -12580,7 +12851,7 @@ ${normalized}`).digest("hex");
     this.maintenanceScheduler.requestQmdMaintenanceForTool(reason);
   }
   async persistExtraction(result, storage, threadIdForExtraction, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps = resolveGraphConstructionCapabilities(this.config), lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config)) {
-    const citationEnabled = this.config.inlineSourceAttributionEnabled === true;
+    const citationEnabled = resolvePipelineProcessingCapabilities(this.config).inlineSourceAttribution === true;
     const citationTemplate = this.config.inlineSourceAttributionFormat;
     const citationContextBase = citationEnabled ? {
       agent: sourceContext?.principal,
@@ -12677,7 +12948,7 @@ ${normalized}`).digest("hex");
         const actualTier = confidenceTier(confidence);
         const actualRank = confidenceTierOrder.indexOf(actualTier);
         if (actualRank === -1) return false;
-        if (!this.config.autoPromoteToSharedEnabled) return false;
+        if (!resolveRecallEnhancementCapabilities(this.config).autoPromoteToShared) return false;
         if (!this.config.autoPromoteToSharedCategories.includes(category))
           return false;
         const minimumRank = confidenceTierOrder.indexOf(
@@ -13428,7 +13699,7 @@ ${normalized}`).digest("hex");
       const requireSpansPendingStatus = this.config.provenance?.requireSpans === true && fact.requireSpansPending === true ? "pending_review" : void 0;
       const faithfulnessEnforceStatus = faithfulnessGateStatus ?? requireSpansPendingStatus;
       let pendingSemanticSkip = null;
-      if (this.config.semanticDedupEnabled) {
+      if (resolvePipelineProcessingCapabilities(this.config).semanticDedup) {
         let semanticDecision;
         if (batchBackendUnavailable) {
           semanticDecision = { action: "keep", reason: "backend_unavailable" };
@@ -13461,7 +13732,7 @@ ${normalized}`).digest("hex");
           pendingSemanticSkip = semanticDecision;
         }
       }
-      const inferredIntent = this.config.intentRoutingEnabled ? inferIntentFromText(
+      const inferredIntent = resolveConversationContextCapabilities(this.config).intentRouting ? inferIntentFromText(
         `${writeCategory} ${fact.tags.join(" ")} ${fact.content}`
       ) : null;
       const extractionWriteSource = fact.source === "proactive" ? "extraction-proactive" : "extraction";
@@ -13469,7 +13740,7 @@ ${normalized}`).digest("hex");
       let links = [];
       let contradictionDetected = false;
       let contradiction;
-      if (this.config.contradictionDetectionEnabled && this.qmd.isAvailable() && faithfulnessEnforceStatus !== "pending_review") {
+      if (resolveRecallEnhancementCapabilities(this.config).contradictionDetection && this.qmd.isAvailable() && faithfulnessEnforceStatus !== "pending_review") {
         const targetNamespace = this.storageDirNamespace(targetStorage.dir);
         contradiction = await this.checkForContradiction(
           fact.content,
@@ -13499,9 +13770,9 @@ ${normalized}`).digest("hex");
         dedupedCount++;
         continue;
       }
-      if (this.config.chunkingEnabled && writeCategory !== "procedure") {
+      if (resolvePipelineProcessingCapabilities(this.config).chunking && writeCategory !== "procedure") {
         let chunkResult;
-        if (this.config.semanticChunkingEnabled) {
+        if (resolvePipelineProcessingCapabilities(this.config).semanticChunking) {
           try {
             const embedFn = this.embeddingFallback.embedTexts.bind(this.embeddingFallback);
             const semanticResult = await semanticChunkContent(
@@ -13752,7 +14023,7 @@ ${normalized}`).digest("hex");
           continue;
         }
       }
-      if (this.config.memoryLinkingEnabled && this.qmd.isAvailable()) {
+      if (resolveRecallEnhancementCapabilities(this.config).memoryLinking && this.qmd.isAvailable()) {
         const targetNamespace = this.storageDirNamespace(targetStorage.dir);
         const suggestedLinks = await this.suggestLinksForMemory(
           fact.content,
@@ -13964,7 +14235,7 @@ ${normalized}`).digest("hex");
         log.warn(`persistExtraction: entity write failed: ${err}`);
       }
     }
-    if (this.config.entityRelationshipsEnabled && Array.isArray(result.relationships)) {
+    if (resolveRecallEnhancementCapabilities(this.config).entityRelationships && Array.isArray(result.relationships)) {
       for (const rel of result.relationships.slice(0, 5)) {
         if (!rel.source || !rel.target || !rel.label) continue;
         try {
@@ -13983,7 +14254,7 @@ ${normalized}`).digest("hex");
         }
       }
     }
-    if (this.config.entityActivityLogEnabled) {
+    if (resolveRecallEnhancementCapabilities(this.config).entityActivityLog) {
       const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       for (const entity of entities) {
         const name = entity?.name;
@@ -14012,7 +14283,7 @@ ${normalized}`).digest("hex");
         recordDurableNonFactWrite();
       }
     }
-    if (this.config.identityEnabled && result.identityReflection) {
+    if (resolveRecallEnhancementCapabilities(this.config).identity && result.identityReflection) {
       try {
         await storage.appendIdentityReflection(result.identityReflection);
         recordDurableNonFactWrite();
@@ -14098,7 +14369,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);
           }
         }
@@ -14395,7 +14666,7 @@ ${normalized}`).digest("hex");
       const tierMigration = await this.runTierMigrationCycle(this.storage, "maintenance");
       if (tierMigration.migrated > 0) memoryItemMutated = true;
       allMemories = await this.storage.readAllMemories();
-      if (this.config.factArchivalEnabled) {
+      if (resolveRecallEnhancementCapabilities(this.config).factArchival) {
         const archived = await this.runFactArchival(allMemories);
         if (archived > 0) {
           memoryItemMutated = true;
@@ -14422,7 +14693,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 +14741,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,
@@ -14485,7 +14756,7 @@ ${normalized}`).digest("hex");
         );
       }
     }
-    if (this.config.identityEnabled) {
+    if (resolveRecallEnhancementCapabilities(this.config).identity) {
       await this.autoConsolidateIdentity();
     }
     const profileSection = this.getRecallSectionEntry("profile");
@@ -14510,10 +14781,10 @@ ${normalized}`).digest("hex");
         }
       }
     }
-    if (this.config.summarizationEnabled) {
+    if (resolvePipelineProcessingCapabilities(this.config).summarization) {
       await this.runSummarization(allMemories);
     }
-    if (this.config.topicExtractionEnabled) {
+    if (resolvePipelineProcessingCapabilities(this.config).topicExtraction) {
       await this.runTopicExtraction(allMemories);
     }
     const meta = await this.storage.loadMeta();
@@ -14791,7 +15062,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 +15092,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 +15133,7 @@ ${reflectionsContent.trim()}
         return null;
       }
     }
-    if (path4.isAbsolute(resultPath)) {
+    if (path5.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -14901,7 +15172,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 +15196,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 +15223,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 +15245,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 +15336,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 +15360,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 +15557,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 +15581,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)
           )) {
@@ -15663,7 +15738,7 @@ ${reflectionsContent.trim()}
    * Updates are batched in memory and flushed during consolidation.
    */
   trackMemoryAccess(memoryIds) {
-    if (!this.config.accessTrackingEnabled) return;
+    if (!resolveRecallEnhancementCapabilities(this.config).accessTracking) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const id of memoryIds) {
       const existing = this.accessTrackingBuffer.get(id);
@@ -15963,7 +16038,7 @@ ${reflectionsContent.trim()}
       temporalFromDate !== null ? queryByDateRangeAsync(this.config.memoryDir, temporalFromDate) : Promise.resolve(null),
       promptTags.length > 0 ? queryByTagsAsync(this.config.memoryDir, promptTags) : Promise.resolve(null)
     ]);
-    const queryIntent = this.config.intentRoutingEnabled && prompt ? inferIntentFromText(prompt) : null;
+    const queryIntent = resolveConversationContextCapabilities(this.config).intentRouting && prompt ? inferIntentFromText(prompt) : null;
     let temporalCandidates = null;
     let tagCandidates = null;
     if (resolveIndexingCapabilities(this.config).queryAwareIndexing && prompt) {
@@ -16013,7 +16088,7 @@ ${reflectionsContent.trim()}
             importanceBoost >= 0 ? "boost" : "suppress"
           );
         }
-        if (this.config.feedbackEnabled) {
+        if (resolveRecallEnhancementCapabilities(this.config).feedback) {
           const match = memory.path.match(/([^/]+)\.md$/);
           const memoryId = match ? match[1] : null;
           if (memoryId) {
@@ -16025,7 +16100,7 @@ ${reflectionsContent.trim()}
             );
           }
         }
-        if (this.config.negativeExamplesEnabled) {
+        if (resolvePipelineProcessingCapabilities(this.config).negativeExamples) {
           const match = memory.path.match(/([^/]+)\.md$/);
           const memoryId = match ? match[1] : null;
           if (memoryId) {
@@ -16080,7 +16155,7 @@ ${reflectionsContent.trim()}
           lifecycleDelta >= 0 ? "boost" : "suppress"
         );
         let reinforcementBoost = 0;
-        if (this.config.reinforcementRecallBoostEnabled && typeof memory.frontmatter.reinforcement_count === "number" && memory.frontmatter.reinforcement_count > 0) {
+        if (resolveRecallEnhancementCapabilities(this.config).reinforcementRecallBoost && typeof memory.frontmatter.reinforcement_count === "number" && memory.frontmatter.reinforcement_count > 0) {
           reinforcementBoost = Math.min(
             memory.frontmatter.reinforcement_count * this.config.reinforcementRecallBoostWeight,
             this.config.reinforcementRecallBoostMax
@@ -16441,4 +16516,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-EKQ3LWBM.js.map
+//# sourceMappingURL=chunk-VC7QELR6.js.map