@remnic/core 9.3.738 → 9.3.740

package/src/orchestrator.ts

@@ -102,6 +102,8 @@ import { SemanticConsolidationCoordinator } from "./orchestration/semantic-conso
 import { LifecyclePolicyCoordinator } from "./orchestration/lifecycle-policy-coordinator.js";
 import { EntitySynthesisCoordinator } from "./orchestration/entity-synthesis-coordinator.js";
 import { RecallResultFormatter } from "./orchestration/recall-result-formatter.js";
+import { ConversationIndexCoordinator } from "./orchestration/conversation-index-coordinator.js";
+import { RecallRerankCoordinator } from "./orchestration/recall-rerank-coordinator.js";
 export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
 import {
   runLiveConnectorsOnce,
@@ -121,16 +123,8 @@ import {
   type ParallelSearchResult,
 } from "./retrieval-agents.js";
 import { RerankCache, rerankLocalOrNoop } from "./rerank.js";
-import {
-  applyMemoryWorthFilter,
-  buildMemoryWorthCounterMap,
-  type MemoryWorthCounters,
-} from "./memory-worth-filter.js";
-import { applyTrustScoreStage, buildTrustSignalsForRerank, projectTrustForXray } from "./trust-score-stage.js";
+import { projectTrustForXray } from "./trust-score-stage.js";
 import type { TrustStageResultItem } from "./trust-score-stage.js";
-import { renderEpistemicHedge, type TrustSignals } from "./trust-score.js";
-import { reorderRecallResultsWithMmr } from "./recall-mmr.js";
-import { applyReasoningTraceBoost } from "./reasoning-trace-recall.js";
 import { buildRetrievedMemoryProvenance } from "./memory-provenance.js";
 import {
   applyTemporalSupersession,
@@ -281,7 +275,11 @@ import { resolveNamespaceCapabilities,
   resolveQmdCapabilities,
   resolveIdentityContinuityCapabilities,
   resolveLocalLlmCapabilities,
-  resolveSecurityCapabilities, resolveEvalCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities, resolveCompressionCapabilities, resolvePresentationCapabilities, resolveConsolidationCapabilities, resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
+  resolveSecurityCapabilities, resolveEvalCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities, resolveCompressionCapabilities, resolvePresentationCapabilities, resolveConsolidationCapabilities, resolveRecallAuxiliaryCapabilities ,
+  resolveRecallEnhancementCapabilities,
+  resolvePipelineProcessingCapabilities,
+  resolveConversationContextCapabilities,
+} from "./capabilities.js";
 import { DEFAULT_TAXONOMY } from "./taxonomy/index.js";
 import {
   searchHarmonicRetrieval,
@@ -330,9 +328,6 @@ import {
   type SemanticConsolidationLlmOperator,
   type SemanticConsolidationResult,
 } from "./semantic-consolidation.js";
-import { chunkTranscriptEntries } from "./conversation-index/chunker.js";
-import { writeConversationChunks } from "./conversation-index/indexer.js";
-import { cleanupConversationChunks } from "./conversation-index/cleanup.js";
 import {
   type ConversationIndexBackend,
   type ConversationIndexBackendInspection,
@@ -1817,31 +1812,6 @@ export class Orchestrator {
   readonly lcmEngine: LcmEngine | null = null;
   private readonly 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.
-   */
-  private readonly memoryWorthCounterCache = new Map<
-    string,
-    { at: number; counters: ReadonlyMap<string, MemoryWorthCounters> }
-  >();
-  private static readonly MEMORY_WORTH_CACHE_TTL_MS = 30_000;
-  /**
-   * 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.
-   */
-  private readonly trustSignalCache = new Map<
-    string,
-    { at: number; signals: ReadonlyMap<string, TrustSignals> }
-  >();
-  private static readonly TRUST_SIGNAL_CACHE_TTL_MS = 30_000;
   /**
    * Per-session workspace selections keyed by sessionKey.
    * Set by the before_agent_start hook so recall() uses the correct
@@ -1909,6 +1879,12 @@ export class Orchestrator {
    * to RecallResultFormatter.
    */
   readonly recallResultFormatter: RecallResultFormatter;
+  /**
+   * Issue #1526: conversation-index subsystem moved to
+   * ConversationIndexCoordinator.
+   */
+  readonly conversationIndexCoordinator: ConversationIndexCoordinator;
+  readonly recallRerankCoordinator: RecallRerankCoordinator;
   private heartbeatObserverChains = new Map<string, Promise<void>>();
   private recentExtractionFingerprints = new Map<string, number>();
   private readonly consolidationObservers = new Set<
@@ -1917,7 +1893,6 @@ export class Orchestrator {
   private wearablesServiceInstance: WearablesService | null = null;
   private wearablesAutoSyncHandle: { stop(): Promise<void> } | null = null;
   private lastQmdReprobeAtMs = 0;
-  private readonly conversationIndexLastUpdateAtMs = new Map<string, number>();
   private lastFileHygieneRunAtMs = 0;
   // Pattern-reinforcement cadence gate (issue #687 PR 2/4).  Tracks the
   // last successful run so `runPatternReinforcement` can short-circuit
@@ -2796,7 +2771,7 @@ export class Orchestrator {
   constructor(config: PluginConfig) {
     this.config = config;
     this.profiler = new ProfilingCollector({
-      enabled: config.profilingEnabled,
+      enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
       storageDir: config.profilingStorageDir || path.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces,
     });
@@ -2885,7 +2860,7 @@ export class Orchestrator {
     this.conversationQmd = conversationIndexRuntime.qmd;
     this.conversationFaiss = conversationIndexRuntime.faiss;
     this.conversationIndexBackend = conversationIndexRuntime.backend;
-    this.sharedContext = config.sharedContextEnabled
+    this.sharedContext = resolveConversationContextCapabilities(this.config).sharedContext
       ? new SharedContextManager(config)
       : undefined;
     this.compounding = resolveConsolidationCapabilities(config).compounding
@@ -2898,6 +2873,18 @@ export class Orchestrator {
       "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);
@@ -2951,7 +2938,7 @@ export class Orchestrator {
     // timeout.  Operators can set `localLlmDisableThinking: false`
     // when they want thinking enabled for narrative paths.
     this.localLlm.disableThinking = config.localLlmDisableThinking;
-    this.fastLlm = config.localLlmFastEnabled
+    this.fastLlm = resolvePipelineProcessingCapabilities(this.config).localLlmFast
       ? (() => {
           const client = new LocalLlmClient(
             {
@@ -3024,7 +3011,7 @@ export class Orchestrator {
     });
 
     // Lossless Context Management (LCM) — proactive session archive + DAG summarization
-    if (config.lcmEnabled) {
+    if (resolvePipelineProcessingCapabilities(this.config).lcm) {
       const summarizeFn = async (
         text: string,
         targetTokens: number,
@@ -3081,7 +3068,7 @@ export 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,
@@ -3174,7 +3161,7 @@ export class Orchestrator {
   }
 
   private async loadRoutingRules(): Promise<RouteRule[]> {
-    if (!this.config.routingRulesEnabled) return [];
+    if (!resolvePipelineProcessingCapabilities(this.config).routingRules) return [];
     try {
       return await this.getRoutingRulesStore().read(this.routeEngineOptions());
     } catch (err) {
@@ -5006,63 +4993,21 @@ export class Orchestrator {
     retrievalQuery: string,
     topK: number,
   ): Promise<Array<{ path: string; snippet: string; score: number }>> {
-    if (this.conversationIndexBackend) {
-      return this.conversationIndexBackend.search(retrievalQuery, topK);
-    }
-    return [];
+    return this.conversationIndexCoordinator.search(retrievalQuery, topK);
   }
 
   private formatConversationRecallSection(
     results: Array<{ path: string; snippet: string; score: number }>,
     maxChars: number,
   ): string | null {
-    if (!Array.isArray(results) || results.length === 0) return null;
-    const lines: string[] = ["## Semantic Recall (Past Conversations)", ""];
-    let used = 0;
-    for (const r of results) {
-      if (!r?.snippet) continue;
-      const chunk =
-        `### ${r.path}\n` +
-        `Score: ${r.score.toFixed(3)}\n\n` +
-        `${r.snippet.trim()}\n`;
-      if (used + chunk.length > maxChars) break;
-      lines.push(chunk);
-      used += chunk.length;
-    }
-    return used > 0 ? lines.join("\n") : null;
-  }
-
-  private async countConversationChunkDocs(dir: string): Promise<number> {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-      let total = 0;
-      for (const entry of entries) {
-        const fullPath = path.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;
-    }
+    return this.conversationIndexCoordinator.formatRecallSection(
+      results,
+      maxChars,
+    );
   }
 
-  private async buildConversationIndexChunks(
-    sessionKey?: string,
-    hours: number = 24,
-  ): Promise<ReturnType<typeof chunkTranscriptEntries>> {
-    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),
-    });
-  }
+  // Issue #1526: countConversationChunkDocs / buildConversationIndexChunks moved
+  // to ConversationIndexCoordinator (internal helpers, no orchestrator callers).
 
   async getConversationIndexHealth(): Promise<{
     enabled: boolean;
@@ -5087,37 +5032,7 @@ export class Orchestrator {
       };
     };
   }> {
-    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" as const,
-        };
-    return {
-      enabled: true,
-      chunkDocCount,
-      lastUpdateAt,
-      ...backendHealth,
-    };
+    return this.conversationIndexCoordinator.getHealth();
   }
 
   async inspectConversationIndex(): Promise<
@@ -5127,53 +5042,7 @@ export class Orchestrator {
       lastUpdateAt: string | null;
     }
   > {
-    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" as const,
-          available: false,
-          indexPath: this.conversationIndexDir,
-          supportsIncrementalUpdate: true,
-          message: "Conversation index backend unavailable",
-          metadata: {
-            chunkCount: chunkDocCount,
-          },
-        };
-
-    return {
-      enabled: true,
-      chunkDocCount,
-      lastUpdateAt,
-      ...inspection,
-    };
+    return this.conversationIndexCoordinator.inspect();
   }
 
   async getRecoverySummary(sessionKey?: string): Promise<{
@@ -5199,54 +5068,7 @@ export class Orchestrator {
     retryAfterMs?: number;
     embedded?: boolean;
   }> {
-    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 * 1000
-        : undefined;
-    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 !== undefined ? { 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(
@@ -5260,42 +5082,7 @@ export class Orchestrator {
     embedded?: boolean;
     rebuilt?: boolean;
   }> {
-    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);
   }
 
   /**
@@ -7089,7 +6876,7 @@ export class Orchestrator {
             signal: options.abortSignal,
           });
     if (
-      this.config.recallPlannerTelemetryEnabled &&
+      resolveRecallEnhancementCapabilities(this.config).recallPlannerTelemetry &&
       recallDecision.plannerSource &&
       recallDecision.plannerSource !== "heuristic"
     ) {
@@ -7623,7 +7410,7 @@ export class Orchestrator {
       if (
         !this.isRecallSectionEnabled(
           "shared-context",
-          this.config.sharedContextEnabled === true,
+          resolveConversationContextCapabilities(this.config).sharedContext === true,
         )
       )
         return null;
@@ -7747,7 +7534,7 @@ export class Orchestrator {
       | null
       | undefined = undefined;
     const peerProfileRecallPromise = (async (): Promise<string | null> => {
-      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;
@@ -8154,11 +7941,11 @@ export class Orchestrator {
     const causalTrajectoryPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.causalTrajectoryMemoryEnabled ||
-        !this.config.causalTrajectoryRecallEnabled ||
+        !resolveRecallEnhancementCapabilities(this.config).causalTrajectoryMemory ||
+        !resolveRecallEnhancementCapabilities(this.config).causalTrajectoryRecall ||
         !this.isRecallSectionEnabled(
           "causal-trajectories",
-          this.config.causalTrajectoryRecallEnabled === true,
+          resolveRecallEnhancementCapabilities(this.config).causalTrajectoryRecall === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -8211,10 +7998,10 @@ export class Orchestrator {
     const cmcRetrievalPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.cmcRetrievalEnabled ||
+        !resolveRecallEnhancementCapabilities(this.config).cmcRetrieval ||
         !this.isRecallSectionEnabled(
           "cmc-causal-chains",
-          this.config.cmcRetrievalEnabled === true,
+          resolveRecallEnhancementCapabilities(this.config).cmcRetrieval === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -9212,7 +8999,7 @@ export class Orchestrator {
       let section: string | null = null;
       // Try checkpoint first (post-compaction recovery)
       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}`,
@@ -9345,7 +9132,7 @@ export class Orchestrator {
     const summariesPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.hourlySummariesEnabled ||
+        !resolvePipelineProcessingCapabilities(this.config).hourlySummaries ||
         !sessionKey ||
         !this.isRecallSectionEnabled("summaries", true)
       ) {
@@ -9575,7 +9362,7 @@ export class Orchestrator {
         const t0 = Date.now();
         if (
           !this.compounding ||
-          !this.config.compoundingInjectEnabled ||
+          !resolveRecallEnhancementCapabilities(this.config).compoundingInject ||
           !this.isRecallSectionEnabled("compounding", true)
         ) {
           recordRecallSectionMetric({
@@ -9916,7 +9703,7 @@ export class Orchestrator {
       this.getRecallSectionMaxChars("explicit-cue") ??
       this.config.explicitCueRecallMaxChars;
     if (
-      this.config.explicitCueRecallEnabled &&
+      resolveRecallEnhancementCapabilities(this.config).explicitCueRecall &&
       this.isRecallSectionEnabled("explicit-cue") &&
       explicitCueMaxChars !== 0 &&
       this.lcmEngine?.enabled &&
@@ -9959,7 +9746,7 @@ export class Orchestrator {
     if (
       this.isSpecializedRecallSectionEnabled(
         "targeted-facts",
-        this.config.targetedFactRecallEnabled,
+        resolveRecallEnhancementCapabilities(this.config).targetedFactRecall,
       ) &&
       targetedFactMaxChars !== 0 &&
       this.lcmEngine?.enabled &&
@@ -10008,7 +9795,7 @@ export class Orchestrator {
     if (
       this.isSpecializedRecallSectionEnabled(
         "focused-list",
-        this.config.focusedListRecallEnabled,
+        resolveRecallEnhancementCapabilities(this.config).focusedListRecall,
       ) &&
       focusedListMaxChars !== 0 &&
       this.lcmEngine?.enabled &&
@@ -10062,7 +9849,7 @@ export class Orchestrator {
     if (
       this.isSpecializedRecallSectionEnabled(
         "response-guidance",
-        this.config.responseGuidanceRecallEnabled,
+        resolveRecallEnhancementCapabilities(this.config).responseGuidanceRecall,
       ) &&
       responseGuidanceMaxChars !== 0 &&
       this.lcmEngine?.enabled &&
@@ -10111,7 +9898,7 @@ export class Orchestrator {
     if (
       this.isSpecializedRecallSectionEnabled(
         "event-order",
-        this.config.eventOrderRecallEnabled,
+        resolveRecallEnhancementCapabilities(this.config).eventOrderRecall,
       ) &&
       eventOrderMaxChars !== 0 &&
       this.lcmEngine?.enabled &&
@@ -10537,7 +10324,7 @@ export class Orchestrator {
         recallMode === "graph_mode" || isFullModeGraphAssist;
       const graphShadowEvalEnabled =
         isFullModeGraphAssist &&
-        this.config.graphAssistShadowEvalEnabled === true;
+        resolveRecallEnhancementCapabilities(this.config).graphAssistShadowEval === true;
       if (shouldRunGraphExpansion) {
         shouldPersistGraphSnapshot = true;
         graphDecisionShadowMode = graphShadowEvalEnabled;
@@ -10801,7 +10588,7 @@ export class Orchestrator {
       );
 
       // E-Mem-inspired memory reconstruction: fill gaps for referenced entities
-      if (this.config.memoryReconstructionEnabled && memoryResults.length > 0) {
+      if (resolveRecallEnhancementCapabilities(this.config).memoryReconstruction && memoryResults.length > 0) {
         try {
           const snippets = memoryResults.map((r) => r.snippet);
           // Extract entity paths already present in recall results to avoid duplicates
@@ -12465,7 +12252,7 @@ export class Orchestrator {
     sessionKey: string,
     options: { bufferKey?: string } = {},
   ): Promise<void> {
-    if (this.config.sessionObserverEnabled !== true) return;
+    if (resolvePipelineProcessingCapabilities(this.config).sessionObserver !== true) return;
     if (!sessionKey || sessionKey.length === 0) return;
 
     const bufferKey =
@@ -13489,7 +13276,7 @@ export class Orchestrator {
     // the citation survives hostile memory text, copy/paste, and LLM quoting.
     // The helper is a no-op when the feature flag is off, so legacy pipelines
     // see zero behavioral change.
-    const citationEnabled = this.config.inlineSourceAttributionEnabled === true;
+    const citationEnabled = resolvePipelineProcessingCapabilities(this.config).inlineSourceAttribution === true;
     const citationTemplate = this.config.inlineSourceAttributionFormat;
     // The stable fields (agent, session) are computed once; `ts` is intentionally
     // omitted here and added fresh per invocation so each fact in a large batch
@@ -13648,7 +13435,7 @@ export class Orchestrator {
         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 as any))
           return false;
         const minimumRank = confidenceTierOrder.indexOf(
@@ -15048,7 +14835,7 @@ export class Orchestrator {
       // a high-similarity update/correction is linked as a superseding
       // contradiction rather than silently dropped.
       let pendingSemanticSkip: (SemanticDedupDecision & { action: "skip" }) | null = null;
-      if (this.config.semanticDedupEnabled) {
+      if (resolvePipelineProcessingCapabilities(this.config).semanticDedup) {
         let semanticDecision: SemanticDedupDecision;
         // UUI2: skip embedding lookup for the rest of this batch once we know
         // the backend is unavailable. The flag is reset per-batch (set to false
@@ -15093,7 +14880,7 @@ export class Orchestrator {
         }
       }
 
-      const inferredIntent = this.config.intentRoutingEnabled
+      const inferredIntent = resolveConversationContextCapabilities(this.config).intentRouting
         ? inferIntentFromText(
             `${writeCategory} ${fact.tags.join(" ")} ${fact.content}`,
           )
@@ -15133,7 +14920,7 @@ export class Orchestrator {
       // for a pending_review fact — an unfaithful extraction in the review queue
       // must not trigger auto-resolve and retire an existing active memory.
       if (
-        this.config.contradictionDetectionEnabled &&
+        resolveRecallEnhancementCapabilities(this.config).contradictionDetection &&
         this.qmd.isAvailable() &&
         faithfulnessEnforceStatus !== "pending_review"
       ) {
@@ -15218,10 +15005,10 @@ export class Orchestrator {
       // When semanticChunkingEnabled is true, prefer the embedding-based
       // semantic chunker which produces more coherent topic-aligned segments.
       // Falls back to the recursive sentence-boundary chunker on failure.
-      if (this.config.chunkingEnabled && writeCategory !== "procedure") {
+      if (resolvePipelineProcessingCapabilities(this.config).chunking && writeCategory !== "procedure") {
         let chunkResult: { chunked: boolean; chunks: { content: string; index: number; tokenCount: number }[] };
 
-        if (this.config.semanticChunkingEnabled) {
+        if (resolvePipelineProcessingCapabilities(this.config).semanticChunking) {
           try {
             const embedFn = this.embeddingFallback.embedTexts.bind(this.embeddingFallback);
             const semanticResult: SemanticChunkResult = await semanticChunkContent(
@@ -15588,7 +15375,7 @@ export class Orchestrator {
       }
 
       // Suggest links for this memory (Phase 3A)
-      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,
@@ -15908,7 +15695,7 @@ export class Orchestrator {
 
     // Persist entity relationships (v7.0)
     if (
-      this.config.entityRelationshipsEnabled &&
+      resolveRecallEnhancementCapabilities(this.config).entityRelationships &&
       Array.isArray(result.relationships)
     ) {
       for (const rel of result.relationships.slice(0, 5)) {
@@ -15932,7 +15719,7 @@ export class Orchestrator {
     }
 
     // Persist entity activity (v7.0)
-    if (this.config.entityActivityLogEnabled) {
+    if (resolveRecallEnhancementCapabilities(this.config).entityActivityLog) {
       const today = new Date().toISOString().slice(0, 10);
       for (const entity of entities) {
         const name = (entity as any)?.name;
@@ -15970,7 +15757,7 @@ export class Orchestrator {
     // counts as a durable non-fact write for the catalog touch below (NIIly).
     // Only count it when the write actually succeeds (best-effort write); the
     // touch is recorded AFTER this so a rolled-back/failed write never touches.
-    if (this.config.identityEnabled && result.identityReflection) {
+    if (resolveRecallEnhancementCapabilities(this.config).identity && result.identityReflection) {
       try {
         await storage.appendIdentityReflection(result.identityReflection);
         recordDurableNonFactWrite();
@@ -16537,7 +16324,7 @@ export class Orchestrator {
       allMemories = await this.storage.readAllMemories();
 
       // Fact archival pass (v6.0) — move old, low-importance, rarely-accessed facts to archive/
-      if (this.config.factArchivalEnabled) {
+      if (resolveRecallEnhancementCapabilities(this.config).factArchival) {
         const archived = await this.runFactArchival(allMemories);
         if (archived > 0) {
           memoryItemMutated = true;
@@ -16635,7 +16422,7 @@ export class Orchestrator {
     }
 
     // Auto-consolidate IDENTITY.md if it's getting large
-    if (this.config.identityEnabled) {
+    if (resolveRecallEnhancementCapabilities(this.config).identity) {
       await this.autoConsolidateIdentity();
     }
 
@@ -16675,12 +16462,12 @@ export class Orchestrator {
     }
 
     // Memory Summarization (Phase 4A)
-    if (this.config.summarizationEnabled) {
+    if (resolvePipelineProcessingCapabilities(this.config).summarization) {
       await this.runSummarization(allMemories);
     }
 
     // Topic Extraction (Phase 4B)
-    if (this.config.topicExtractionEnabled) {
+    if (resolvePipelineProcessingCapabilities(this.config).topicExtraction) {
       await this.runTopicExtraction(allMemories);
     }
 
@@ -17365,156 +17152,15 @@ export class Orchestrator {
     return matches[0] ?? null;
   }
 
+  // Issue #1526: recall-rerank methods moved to RecallRerankCoordinator.
+  // Thin delegation keeps the private API stable for callers + tests.
   private async applyMemoryWorthRerank(
     results: QmdSearchResult[],
     namespaces: string[],
   ): Promise<QmdSearchResult[]> {
-    // Build the counter lookup. We union frontmatter counters across every
-    // namespace the recall spans — the recall path itself already
-    // aggregates candidates from multiple namespaces, so we must do the
-    // same when looking up counters. Per-namespace results are cached with
-    // a short TTL so interactive recall doesn't trigger a full
-    // `readAllMemories` scan per query (addresses codex P2 on PR 4).
-    const counters = new Map<string, MemoryWorthCounters>();
-    const seenNamespaces = new Set<string>();
-    const nowMs = Date.now();
-
-    // Evict all expired entries on every call so long-running processes
-    // touching a high-cardinality namespace set (coding/project overlays,
-    // per-branch) don't grow the cache unboundedly. Without this, an entry
-    // for a namespace that's never looked up again would pin its full
-    // counter map forever.
-    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: ReadonlyMap<string, MemoryWorthCounters> | undefined;
-        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 [path, c] of nsMap) counters.set(path, c);
-      } catch (err) {
-        log.debug("memory-worth: failed to read namespace, skipping", {
-          namespace: ns,
-          error: (err as Error).message,
-        });
-      }
-    }
-
-    // For candidates whose path didn't show up in any hot-tier namespace
-    // scan (typical of cold-tier / archive fallback), try a direct
-    // per-path read. Without this, cold-tier candidates always stay at
-    // multiplier 1.0 even when they have outcome history. Errors are
-    // swallowed so a single unreadable archive entry can't break the
-    // whole recall.
-    const missing = results.filter((r) => !counters.has(r.path));
-    if (missing.length > 0) {
-      // Use the first-seen namespace's storage as the reader — all
-      // StorageManagers share the same on-disk format, and
-      // `readMemoryByPath` takes an absolute path so the baseDir doesn't
-      // have to match.
-      let reader: StorageManager | null = null;
-      for (const ns of namespaces) {
-        try {
-          reader = await this.getStorage(ns);
-          break;
-        } catch {
-          // try next namespace
-        }
-      }
-      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 === undefined && fm.mw_fail === undefined) 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 as Error).message,
-            });
-          }
-        }
-      }
-    }
-
-    // If no memory in the candidate set has any counter data, the filter
-    // would be a no-op — skip the reorder to avoid spurious log spam.
-    if (counters.size === 0) return results;
-
-    // Preserve upstream ordering (reranker, specialized tiers, etc.) for
-    // neutral candidates. The upstream stages set `memoryResults` in their
-    // intended order but often leave `r.score` as the raw QMD score. If we
-    // sorted by `r.score * multiplier` directly, neutral candidates
-    // (multiplier 1.0) would snap back to raw-QMD order and silently undo
-    // the reranker. Feed the filter a synthetic monotone-decreasing rank
-    // score so it uses input position as the baseline, then applies the
-    // multiplier on top. Ties fall back to the stable secondary key in
-    // `applyMemoryWorthFilter`.
-    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: new Date(),
-      halfLifeMs:
-        this.config.recallMemoryWorthHalfLifeMs > 0
-          ? this.config.recallMemoryWorthHalfLifeMs
-          : undefined,
-    });
-
-    // Reconstruct the QmdSearchResult list in the new order. `.score` is
-    // preserved from the upstream pipeline (rerank, tier scoring, etc.) —
-    // we only reorder. Writing the synthetic rank-weighted score back
-    // would contaminate downstream logic (telemetry, confidence gates)
-    // that expects the original QMD/rerank score semantics.
-    const byPath = new Map(results.map((r) => [r.path, r]));
-    const reordered: QmdSearchResult[] = [];
-    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).
-   */
   private async applyTrustScoreRerank(
     results: QmdSearchResult[],
     namespaces: string[],
@@ -17522,74 +17168,9 @@ export class Orchestrator {
     results: QmdSearchResult[];
     trustByPath: Map<string, TrustStageResultItem> | null;
   }> {
-    if (results.length === 0) return { results, trustByPath: null };
-    const now = new Date();
-    const halfLifeDays =
-      this.config.recallMemoryWorthHalfLifeMs > 0
-        ? this.config.recallMemoryWorthHalfLifeMs / (24 * 60 * 60 * 1000)
-        : undefined;
-    // Cold-tier direct-fallback reader: resolve once, reuse for every missing
-    // candidate (mirrors the memory-worth filter's reader selection).
-    let fallbackReader: StorageManager | null = null;
-    const signals = await buildTrustSignalsForRerank(
-      results.map((r) => r.path),
-      namespaces,
-      {
-        readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path) => {
-          if (!fallbackReader) {
-            for (const ns of namespaces) {
-              try {
-                fallbackReader = await this.getStorage(ns);
-                break;
-              } catch {
-                // try next namespace
-              }
-            }
-          }
-          if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path, 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 };
-    }
-    // Synthetic monotone-decreasing rank so the multiplier rebias is applied
-    // on top of upstream ordering, not raw QMD scores (see applyMemoryWorthRerank).
-    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 is QmdSearchResult => r !== undefined);
-    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.
-   */
   private async applyTrustScoreToBranch(
     results: QmdSearchResult[],
     namespaces: string[],
@@ -17599,25 +17180,7 @@ export class Orchestrator {
     results: QmdSearchResult[];
     trustByPath: Map<string, TrustStageResultItem> | null;
   }> {
-    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 as Error).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 as Error).message,
-        });
-      }
-    }
-    return { results, trustByPath: null };
+    return this.recallRerankCoordinator.applyTrustScoreToBranch(results, namespaces, caps, label);
   }
 
   private diversifyAndLimitRecallResults(
@@ -17625,89 +17188,17 @@ export class Orchestrator {
     results: QmdSearchResult[],
     limit: number,
     retrievalQuery?: string,
-    // `caps` is additive AND last (issue #1523) so the positional call shape
-    // stays backward-compatible: the recall pipeline threads a resolved set,
-    // but callers that omit it (e.g. direct unit-test invocations) get an
-    // equivalent set derived from the same config — behavior-preserving.
     caps: CapabilitySet = resolveCapabilities(this.config),
   ): QmdSearchResult[] {
-    const safeLimit =
-      typeof limit === "number" && Number.isFinite(limit)
-        ? Math.max(0, Math.floor(limit))
-        : 0;
-    if (!Array.isArray(results) || results.length === 0) return [];
-    // `recallResultLimit === 0` is a true zero limit (e.g. when
-    // `memoriesSectionEnabled` is false) and must return an empty array so
-    // the memories section is genuinely skipped. This mirrors the
-    // `slice(0, 0)` semantics of every call site this helper replaced.
-    if (safeLimit === 0) return [];
-    // Issue #564 PR 3: when the feature flag is on, boost reasoning_trace
-    // memories for problem-solving asks so they bubble up ahead of ordinary
-    // facts/decisions before MMR picks the final section. No-op when the
-    // flag is off or the query is not a problem-solving ask.
-    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.
-   */
   private applyMmrToQmdResults(
     sectionId: string,
     results: QmdSearchResult[],
-    // Additive `caps` (issue #1523); defaults to a config-derived set so direct
-    // callers that omit it behave identically to the threaded recall path.
     caps: CapabilitySet = resolveCapabilities(this.config),
   ): QmdSearchResult[] {
-    if (!caps.recallMmr) return results;
-    if (!Array.isArray(results) || results.length < 2) return results;
-
-    // Config is runtime API (see AGENTS.md §4): preserve `0` as a true zero
-    // limit rather than coercing it to a non-zero value. A configured topN of
-    // 0 means "apply MMR over an empty window" — i.e. skip the reorder and
-    // return the upstream candidates unchanged. This keeps read-time
-    // behavior symmetric with the write-time semantics parseConfig exposes.
-    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;
-
-    // Delegate to the pure helper so candidate keying (path-first, index
-    // suffixed for uniqueness) and the head-of-list diversity metric are
-    // exercised by the same code path that the unit tests cover.
-    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 {
-      // Metrics must never break recall.
-    }
-
-    return reordered;
+    return this.recallRerankCoordinator.applyMmrToQmdResults(sectionId, results, caps);
   }
 
   private buildLastRecallBudgetSummary(options: {
@@ -18389,7 +17880,7 @@ export class Orchestrator {
    * Updates are batched in memory and flushed during consolidation.
    */
   trackMemoryAccess(memoryIds: string[]): void {
-    if (!this.config.accessTrackingEnabled) return;
+    if (!resolveRecallEnhancementCapabilities(this.config).accessTracking) return;
 
     const now = new Date().toISOString();
     for (const id of memoryIds) {
@@ -18824,7 +18315,7 @@ export class Orchestrator {
     ]);
 
     const queryIntent =
-      this.config.intentRoutingEnabled && prompt
+      resolveConversationContextCapabilities(this.config).intentRouting && prompt
         ? inferIntentFromText(prompt)
         : null;
 
@@ -18892,7 +18383,7 @@ export class Orchestrator {
         }
 
         // Feedback bias (v2.2): apply small user-provided up/down vote adjustments.
-        if (this.config.feedbackEnabled) {
+        if (resolveRecallEnhancementCapabilities(this.config).feedback) {
           const match = memory.path.match(/([^/]+)\.md$/);
           const memoryId = match ? match[1] : null;
           if (memoryId) {
@@ -18906,7 +18397,7 @@ export class Orchestrator {
         }
 
         // Negative examples (v2.2): apply a small penalty for memories repeatedly marked "not useful".
-        if (this.config.negativeExamplesEnabled) {
+        if (resolvePipelineProcessingCapabilities(this.config).negativeExamples) {
           const match = memory.path.match(/([^/]+)\.md$/);
           const memoryId = match ? match[1] : null;
           if (memoryId) {
@@ -18978,7 +18469,7 @@ export class Orchestrator {
         // Gated by reinforcementRecallBoostEnabled (default false).
         let reinforcementBoost = 0;
         if (
-          this.config.reinforcementRecallBoostEnabled &&
+          resolveRecallEnhancementCapabilities(this.config).reinforcementRecallBoost &&
           typeof memory.frontmatter.reinforcement_count === "number" &&
           memory.frontmatter.reinforcement_count > 0
         ) {