@remnic/core 9.3.742 → 9.3.744

package/dist/{chunk-7HUGLMSW.js → chunk-SODQQCAZ.js}

@@ -7,10 +7,10 @@ import {
 } from "./chunk-C7LDPZJJ.js";
 import {
   CompressionGuidelineCoordinator
-} from "./chunk-WIMKOTNY.js";
+} from "./chunk-5QANTTY2.js";
 import {
   MaintenanceScheduler
-} from "./chunk-BJPL5WAL.js";
+} from "./chunk-MXDG6SRH.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -29,10 +29,10 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UOVDO6TC.js";
+} from "./chunk-CHELXDTO.js";
 import {
   SharedContextManager
-} from "./chunk-WHEF76BQ.js";
+} from "./chunk-JRZV3767.js";
 import {
   applyTrustScoreStage,
   buildTrustSignalsForRerank,
@@ -63,7 +63,7 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-USHVHI6J.js";
+} from "./chunk-NNL4LJAD.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -160,7 +160,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-WGDE2TJP.js";
+} from "./chunk-QOGXUNWL.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -169,7 +169,7 @@ import {
 } from "./chunk-PWFWCGOO.js";
 import {
   LocalLlmClient
-} from "./chunk-TQQN64J2.js";
+} from "./chunk-DBSMLRTO.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -187,18 +187,18 @@ import {
 } from "./chunk-4463LUIE.js";
 import {
   formatDaySummaryMemories
-} from "./chunk-C3Z5YJSM.js";
+} from "./chunk-LOPZ2DWR.js";
 import {
   tryDirectAnswer
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-GPX5E36D.js";
+} from "./chunk-OSMBC3JU.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-K2N6WIZM.js";
+} from "./chunk-E7RGJQWP.js";
 import {
   RoutingRulesStore
 } from "./chunk-WIWPSQYU.js";
@@ -228,14 +228,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-O4IWVWSW.js";
+} from "./chunk-AVBT5WEW.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-X5PMDVY4.js";
+} from "./chunk-3EA5LIFJ.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-AX4TRSRE.js";
+} from "./chunk-U5WVRMCA.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -270,7 +270,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-PI4JHLDD.js";
+} from "./chunk-IP5SANO2.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -292,7 +292,7 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   SmartBuffer
-} from "./chunk-OS5RKJOH.js";
+} from "./chunk-JZ7P26GF.js";
 import {
   isDisagreementPrompt
 } from "./chunk-H3FZVNRN.js";
@@ -311,7 +311,7 @@ import {
   clusterByKey,
   createCorrectionService,
   detectPassiveCorrections
-} from "./chunk-Y6PNYJVO.js";
+} from "./chunk-A2KKLCOS.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -333,14 +333,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-OVYBENIJ.js";
+} from "./chunk-W3M34XT4.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-BE6NEQLF.js";
+} from "./chunk-HAZVVOYT.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-ELL5VYXC.js";
+} from "./chunk-RNWWAS5V.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -363,7 +363,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-Y62QPRKV.js";
+} from "./chunk-K5LLP4CY.js";
 import {
   searchCausalTrajectories
 } from "./chunk-SQNED75R.js";
@@ -465,7 +465,7 @@ import {
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-OUSOMUFV.js";
+} from "./chunk-PE6XR4GG.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule
@@ -491,7 +491,7 @@ import {
   resolveRecallEnhancementCapabilities,
   resolveSecurityCapabilities,
   resolveUtilityLearningCapabilities
-} from "./chunk-G7Q4D2G3.js";
+} from "./chunk-VSF7AAGE.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -512,19 +512,19 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path6 from "path";
+import path7 from "path";
 import os2 from "os";
-import { createHash as createHash2, randomBytes } from "crypto";
+import { createHash as createHash3, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   lstat,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   readdir as readdir2,
   readFile as readFile2,
   realpath,
   stat,
   unlink,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "fs/promises";
 
 // src/procedural/procedure-recall.ts
@@ -2196,7 +2196,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path7, c] of nsMap) counters.set(path7, c);
+        for (const [path8, c] of nsMap) counters.set(path8, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -2281,7 +2281,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path7) => {
+        readMemoryFrontmatter: async (path8) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2292,7 +2292,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
             }
           }
           if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path7, fallbackReader, namespaces);
+          const memory = await this.readQmdResultMemory(path8, fallbackReader, namespaces);
           return memory ? memory.frontmatter : null;
         }
       },
@@ -2391,6 +2391,210 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
   }
 };
 
+// src/orchestration/recall-section-coordinator.ts
+var RecallSectionCoordinator = class {
+  getConfig;
+  resolveSectionEnabled;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.resolveSectionEnabled = options.resolveSectionEnabled ?? ((id, def) => this.isRecallSectionEnabled(id, def));
+  }
+  getRecallSectionEntry(sectionId) {
+    const pipeline = Array.isArray(this.getConfig().recallPipeline) ? this.getConfig().recallPipeline : [];
+    return pipeline.find((entry) => entry.id === sectionId);
+  }
+  isRecallSectionEnabled(sectionId, defaultEnabled = true) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return defaultEnabled;
+    return entry.enabled !== false;
+  }
+  isSpecializedRecallSectionEnabled(sectionId, topLevelEnabled) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return topLevelEnabled;
+    return entry.enabled === true || topLevelEnabled && entry.enabled !== false;
+  }
+  getRecallSectionMaxChars(sectionId) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return void 0;
+    if (entry.maxChars === null) return null;
+    if (typeof entry.maxChars !== "number") return void 0;
+    return Math.max(0, Math.floor(entry.maxChars));
+  }
+  getRecallSectionNumber(sectionId, key) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return void 0;
+    const value = entry[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+    return Math.max(0, Math.floor(value));
+  }
+  appendRecallSection(sectionBuckets, sectionId, content) {
+    if (!this.resolveSectionEnabled(sectionId, true)) return false;
+    const trimmed = content.trim();
+    if (trimmed.length === 0) return false;
+    const maxChars = this.getRecallSectionMaxChars(sectionId);
+    let finalContent = trimmed;
+    if (maxChars === 0) return false;
+    if (typeof maxChars === "number" && finalContent.length > maxChars) {
+      finalContent = `${finalContent.slice(0, maxChars)}
+
+...(trimmed)
+`;
+    }
+    const existing = sectionBuckets.get(sectionId) ?? [];
+    existing.push(finalContent);
+    sectionBuckets.set(sectionId, existing);
+    return true;
+  }
+  truncateRecallSectionToBudget(content, maxChars) {
+    if (maxChars <= 0) return "";
+    if (content.length <= maxChars) return content;
+    const suffix = "\n\n...(memory context trimmed)";
+    if (maxChars <= suffix.length) {
+      return content.slice(0, maxChars);
+    }
+    return `${content.slice(0, maxChars - suffix.length)}${suffix}`;
+  }
+  protectedRecallSectionIds(sectionBuckets) {
+    const protectedIds = /* @__PURE__ */ new Set();
+    if ((sectionBuckets.get("memories")?.length ?? 0) > 0) {
+      protectedIds.add("memories");
+    }
+    return protectedIds;
+  }
+  protectedRecallReservationChars(content) {
+    const headingBoundary = content.indexOf("\n\n");
+    const headingChars = headingBoundary >= 0 ? headingBoundary + 2 : Math.min(content.length, 24);
+    return Math.min(content.length, Math.max(headingChars, 24));
+  }
+  estimateReservedRecallBudget(entries, startIndex, protectedIds, alreadyIncludedCount) {
+    const separatorLength = "\n\n---\n\n".length;
+    let reserved = 0;
+    let simulatedIncluded = alreadyIncludedCount;
+    for (let i = startIndex; i < entries.length; i += 1) {
+      const entry = entries[i];
+      if (!entry || !protectedIds.has(entry.id)) continue;
+      if (simulatedIncluded > 0) {
+        reserved += separatorLength;
+      }
+      reserved += this.protectedRecallReservationChars(entry.content);
+      simulatedIncluded += 1;
+    }
+    return reserved;
+  }
+  getRecallBudgetChars(override) {
+    if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
+      return Math.floor(override);
+    }
+    const configuredBudget = this.getConfig().recallBudgetChars;
+    if (typeof configuredBudget === "number" && Number.isFinite(configuredBudget) && configuredBudget >= 0) {
+      return Math.floor(configuredBudget);
+    }
+    const tokenBudget = this.getConfig().maxMemoryTokens;
+    if (typeof tokenBudget === "number" && Number.isFinite(tokenBudget) && tokenBudget >= 0) {
+      return Math.floor(tokenBudget * 4);
+    }
+    return 0;
+  }
+  assembleRecallSections(sectionBuckets, budgetOverride) {
+    const orderedEntries = [];
+    const pipeline = Array.isArray(this.getConfig().recallPipeline) ? this.getConfig().recallPipeline : [];
+    const orderedIds = pipeline.filter((entry) => entry.enabled !== false).map((entry) => entry.id);
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of orderedIds) {
+      const chunks = sectionBuckets.get(id);
+      if (!chunks || chunks.length === 0) continue;
+      orderedEntries.push({ id, content: chunks.join("\n\n") });
+      seen.add(id);
+    }
+    for (const [id, chunks] of sectionBuckets.entries()) {
+      if (seen.has(id)) continue;
+      if (chunks.length === 0) continue;
+      orderedEntries.push({ id, content: chunks.join("\n\n") });
+    }
+    const budget = this.getRecallBudgetChars(budgetOverride);
+    if (budget === 0) {
+      return {
+        sections: [],
+        includedIds: [],
+        omittedIds: orderedEntries.map((entry) => entry.id),
+        truncated: orderedEntries.length > 0,
+        finalChars: 0
+      };
+    }
+    const separator = "\n\n---\n\n";
+    const protectedIds = this.protectedRecallSectionIds(sectionBuckets);
+    const sections = [];
+    const includedIds = [];
+    const omittedIds = [];
+    let usedChars = 0;
+    let truncated = false;
+    for (let index = 0; index < orderedEntries.length; index += 1) {
+      const entry = orderedEntries[index];
+      const separatorChars = sections.length > 0 ? separator.length : 0;
+      const reserve = protectedIds.has(entry.id) ? 0 : this.estimateReservedRecallBudget(
+        orderedEntries,
+        index + 1,
+        protectedIds,
+        sections.length + 1
+      );
+      const availableForEntry = budget - usedChars - separatorChars - reserve;
+      if (availableForEntry <= 0) {
+        omittedIds.push(entry.id);
+        truncated = true;
+        continue;
+      }
+      const finalContent = this.truncateRecallSectionToBudget(
+        entry.content,
+        availableForEntry
+      );
+      if (!finalContent) {
+        omittedIds.push(entry.id);
+        truncated = true;
+        continue;
+      }
+      if (finalContent.length < entry.content.length) {
+        truncated = true;
+      }
+      sections.push(finalContent);
+      includedIds.push(entry.id);
+      usedChars += separatorChars + finalContent.length;
+    }
+    return {
+      sections,
+      includedIds,
+      omittedIds,
+      truncated,
+      finalChars: usedChars
+    };
+  }
+  buildLastRecallBudgetSummary(options) {
+    return {
+      requestedTopK: options.requestedTopK,
+      appliedTopK: options.recallResultLimit,
+      recallBudgetChars: this.getRecallBudgetChars(),
+      maxMemoryTokens: this.getConfig().maxMemoryTokens,
+      qmdFetchLimit: options.qmdFetchLimit,
+      qmdHybridFetchLimit: options.qmdHybridFetchLimit,
+      finalContextChars: options.finalContextChars,
+      truncated: options.truncated,
+      includedSections: [...options.includedSections ?? []],
+      omittedSections: [...options.omittedSections ?? []]
+    };
+  }
+  collectLastRecallSources(sectionBuckets, recallSource) {
+    const used = /* @__PURE__ */ new Set();
+    if (recallSource !== "none") {
+      used.add(recallSource);
+    }
+    for (const [sectionId, chunks] of sectionBuckets.entries()) {
+      if (chunks.length > 0) {
+        used.add(sectionId);
+      }
+    }
+    return [...used];
+  }
+};
+
 // src/orchestration/qmd-result-resolver.ts
 import path4 from "path";
 function qmdCollectionPathParts(resultPath) {
@@ -2642,63 +2846,522 @@ var QmdResultResolver = class {
   }
 };
 
-// src/maintenance/pattern-reinforcement.ts
-function patternReinforcementKey(content) {
-  return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
-}
-function patternReinforcementClusterKey(category, content) {
-  return `${category}::${patternReinforcementKey(content)}`;
-}
-function pickCanonical(memories) {
-  let best = memories[0];
-  let bestInstant = memoryInstant(best);
-  let bestStamp = memoryStamp(best);
-  for (let i = 1; i < memories.length; i += 1) {
-    const candidate = memories[i];
-    const instant = memoryInstant(candidate);
-    const stamp = memoryStamp(candidate);
-    let cmp;
-    if (instant !== null && bestInstant !== null) {
-      cmp = instant - bestInstant;
-    } else {
-      cmp = stamp.localeCompare(bestStamp);
-    }
-    if (cmp > 0 || cmp === 0 && candidate.frontmatter.id > best.frontmatter.id) {
-      best = candidate;
-      bestInstant = instant;
-      bestStamp = stamp;
-    }
-  }
-  return best;
-}
-function memoryStamp(memory) {
-  return memory.frontmatter.updated || memory.frontmatter.created || "";
-}
-function memoryInstant(memory) {
-  const stamp = memoryStamp(memory);
-  if (stamp.length === 0) return null;
-  const parsed = Date.parse(stamp);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-var ACTIVE_STATUS = "active";
-async function runPatternReinforcement(storage, options) {
-  const minCount = Math.max(2, Math.floor(options.minCount));
-  const targetCategories = new Set(options.categories);
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const nowIso = now().toISOString();
-  if (targetCategories.size === 0) {
-    return emptyResult();
+// src/orchestration/contradiction-linking-coordinator.ts
+var ContradictionLinkingCoordinator = class {
+  getConfig;
+  isSearchAvailable;
+  searchAcrossNamespaces;
+  extractMemoryIdsFromResults;
+  namespaceFromPath;
+  storageForNamespace;
+  getExtraction;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.isSearchAvailable = options.isSearchAvailable;
+    this.searchAcrossNamespaces = options.searchAcrossNamespaces;
+    this.extractMemoryIdsFromResults = options.extractMemoryIdsFromResults;
+    this.namespaceFromPath = options.namespaceFromPath;
+    this.storageForNamespace = options.storageForNamespace;
+    this.getExtraction = options.getExtraction;
   }
-  const memories = await storage.readAllMemories();
-  const eligible = memories.filter((m) => {
-    if (!targetCategories.has(m.frontmatter.category)) return false;
-    const status = m.frontmatter.status ?? ACTIVE_STATUS;
-    return status === ACTIVE_STATUS || status === "superseded";
-  });
-  if (eligible.length === 0) return emptyResult();
-  const clusters = clusterByKey(
-    eligible,
-    (m) => patternReinforcementClusterKey(m.frontmatter.category, m.content)
+  /**
+   * Check if a new memory contradicts an existing one.
+   * Uses QMD to find similar memories, then LLM to verify contradiction.
+   */
+  async checkForContradiction(content, category, namespaceScope) {
+    if (!this.isSearchAvailable()) return null;
+    const config = this.getConfig();
+    const results = await this.searchAcrossNamespaces({
+      query: content,
+      namespaces: [namespaceScope],
+      maxResults: 5,
+      mode: "search"
+    });
+    for (const result of results) {
+      if (result.score < config.contradictionSimilarityThreshold) {
+        continue;
+      }
+      const memoryId = this.extractMemoryIdsFromResults([result])[0];
+      if (!memoryId) continue;
+      const resultNamespace = this.namespaceFromPath(result.path);
+      if (resultNamespace !== namespaceScope) continue;
+      const resultStorage = await this.storageForNamespace(resultNamespace);
+      const existingMemory = await resultStorage.getMemoryById(memoryId);
+      if (!existingMemory) continue;
+      if (existingMemory.frontmatter.status === "superseded" || existingMemory.frontmatter.status === "forgotten") {
+        continue;
+      }
+      const extraction = this.getExtraction();
+      const verification = await extraction.verifyContradiction(
+        { content, category },
+        {
+          id: existingMemory.frontmatter.id,
+          content: existingMemory.content,
+          category: existingMemory.frontmatter.category,
+          created: existingMemory.frontmatter.created
+        }
+      );
+      if (!verification) continue;
+      if (verification.isContradiction && verification.confidence >= config.contradictionMinConfidence) {
+        if (verification.whichIsNewer === "first") {
+          log.info(
+            `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory \u2014 existing is newer, incoming fact is stale`
+          );
+          continue;
+        }
+        log.info(
+          `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory${config.contradictionAutoResolve ? " (auto-resolved)" : " (queued for manual review)"}`
+        );
+        return {
+          supersededId: existingMemory.frontmatter.id,
+          confidence: verification.confidence,
+          reason: verification.reasoning,
+          supersededPath: existingMemory.path,
+          supersededCreated: existingMemory.frontmatter.created,
+          supersededTags: existingMemory.frontmatter.tags ?? []
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * #1645: Complete the deferred contradiction auto-resolve after writeMemory
+   * returns and the new write's tombstone status is known. Retires the old
+   * memory + deindexes it ONLY when the new write is genuinely active (not
+   * tombstone-blocked / pending_review). A blocked write must not retire the
+   * only active copy — deferring here closes the "contradictionAutoResolve
+   * supersedes before tombstone status is known" defect class.
+   */
+  async applyDeferredContradictionResolve(contradiction, storage, newMemoryId, postWriteGuard) {
+    const config = this.getConfig();
+    if (postWriteGuard && contradiction && config.contradictionAutoResolve) {
+      try {
+        const blockedRow = await storage.getMemoryById(newMemoryId);
+        if (blockedRow?.frontmatter?.supersedes) {
+          await storage.writeMemoryFrontmatter(blockedRow, { supersedes: void 0 });
+        }
+      } catch (err) {
+        log.warn(
+          `contradiction auto-resolve supersedes clear failed for blocked ${newMemoryId}: ${err}`
+        );
+      }
+    }
+    if (!contradiction || !config.contradictionAutoResolve || postWriteGuard) {
+      return;
+    }
+    try {
+      await storage.supersedeMemory(
+        contradiction.supersededId,
+        newMemoryId,
+        contradiction.reason
+      );
+      if (resolveIndexingCapabilities(config).queryAwareIndexing && contradiction.supersededPath) {
+        deindexMemory(
+          config.memoryDir,
+          contradiction.supersededPath,
+          contradiction.supersededCreated,
+          contradiction.supersededTags
+        );
+      }
+    } catch (err) {
+      log.warn(
+        `contradiction auto-resolve supersede failed for ${contradiction.supersededId}: ${err}`
+      );
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Memory Linking (Phase 3A)
+  // ---------------------------------------------------------------------------
+  /**
+   * Suggest links for a new memory based on similar existing memories.
+   */
+  async suggestLinksForMemory(content, category, namespaceScope) {
+    if (!this.isSearchAvailable()) return [];
+    const results = await this.searchAcrossNamespaces({
+      query: content,
+      namespaces: [namespaceScope],
+      maxResults: 5,
+      mode: "search"
+    });
+    if (results.length === 0) return [];
+    const candidates = [];
+    for (const result of results) {
+      const memoryId = this.extractMemoryIdsFromResults([result])[0];
+      if (!memoryId) continue;
+      const resultNamespace = this.namespaceFromPath(result.path);
+      if (resultNamespace !== namespaceScope) continue;
+      const resultStorage = await this.storageForNamespace(resultNamespace);
+      const memory = await resultStorage.getMemoryById(memoryId);
+      if (memory && memory.frontmatter.status !== "superseded" && memory.frontmatter.status !== "forgotten") {
+        candidates.push({
+          id: memory.frontmatter.id,
+          content: memory.content,
+          category: memory.frontmatter.category
+        });
+      }
+    }
+    if (candidates.length === 0) return [];
+    const extraction = this.getExtraction();
+    const suggestions = await extraction.suggestLinks(
+      { content, category },
+      candidates
+    );
+    if (!suggestions || suggestions.links.length === 0) return [];
+    return suggestions.links.map((link) => ({
+      targetId: link.targetId,
+      linkType: link.linkType,
+      strength: link.strength,
+      reason: link.reason || void 0
+    }));
+  }
+};
+
+// src/orchestration/graph-recall-coordinator.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+function mergeGraphExpandedResults(primary, expanded) {
+  const mergedByPath = /* @__PURE__ */ new Map();
+  for (const item of [...primary, ...expanded]) {
+    const prev = mergedByPath.get(item.path);
+    if (!prev) {
+      mergedByPath.set(item.path, item);
+      continue;
+    }
+    const better = item.score > prev.score ? item : prev;
+    const snippet = prev.snippet || item.snippet;
+    mergedByPath.set(item.path, { ...better, snippet });
+  }
+  return Array.from(mergedByPath.values());
+}
+function graphPathRelativeToStorage(storageDir, candidatePath) {
+  const absolutePath = path5.isAbsolute(candidatePath) ? candidatePath : path5.resolve(storageDir, candidatePath);
+  const rel = path5.relative(storageDir, absolutePath);
+  if (!rel || rel === ".") return null;
+  if (rel.startsWith("..")) return null;
+  return rel.split(path5.sep).join("/");
+}
+function normalizeGraphActivationScore(score) {
+  const bounded = Number.isFinite(score) && score > 0 ? score : 0;
+  return bounded / (1 + bounded);
+}
+function blendGraphExpandedRecallScore(options) {
+  const graphNorm = normalizeGraphActivationScore(options.graphActivationScore);
+  const seedScore = Number.isFinite(options.seedRecallScore) ? Math.min(1, Math.max(0, options.seedRecallScore)) : 0;
+  const weight = Math.min(1, Math.max(0, options.activationWeight));
+  const rawMin = Math.min(1, Math.max(0, options.blendMin));
+  const rawMax = Math.min(1, Math.max(0, options.blendMax));
+  const minBound = Math.min(rawMin, rawMax);
+  const maxBound = Math.max(rawMin, rawMax);
+  const blended = graphNorm * weight + seedScore * (1 - weight);
+  return Math.max(minBound, Math.min(maxBound, blended));
+}
+var GraphRecallCoordinator = class {
+  getConfig;
+  getStorage;
+  storageFor;
+  graphIndexFor;
+  namespaceFromPath;
+  resolveColdQmdResultForRecall;
+  storageForAbsoluteQmdResultPath;
+  readQmdResultMemory;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.getStorage = options.getStorage;
+    this.storageFor = options.storageFor;
+    this.graphIndexFor = options.graphIndexFor;
+    this.namespaceFromPath = options.namespaceFromPath;
+    this.resolveColdQmdResultForRecall = options.resolveColdQmdResultForRecall;
+    this.storageForAbsoluteQmdResultPath = options.storageForAbsoluteQmdResultPath;
+    this.readQmdResultMemory = options.readQmdResultMemory;
+  }
+  async expandResultsViaGraph(options) {
+    const config = this.getConfig();
+    const deadlineExpired = () => typeof options.deadlineAtMs === "number" && Date.now() >= options.deadlineAtMs;
+    const byNamespace = /* @__PURE__ */ new Map();
+    const addResultForNamespace = (namespace, result) => {
+      const existing = byNamespace.get(namespace);
+      if (existing) {
+        existing.push(result);
+      } else {
+        byNamespace.set(namespace, [result]);
+      }
+    };
+    const resolvedAmbiguousSeeds = /* @__PURE__ */ new Map();
+    const resolveAmbiguousSeedOwner = async (result, parts) => {
+      const cached = resolvedAmbiguousSeeds.get(result.path);
+      if (cached !== void 0) return cached;
+      if (deadlineExpired()) {
+        resolvedAmbiguousSeeds.set(result.path, null);
+        return null;
+      }
+      let resolvedPath = result.path;
+      let resolvedResult = result;
+      if (parts) {
+        const resolvedCold = await this.resolveColdQmdResultForRecall(
+          result,
+          this.getStorage(),
+          options.recallNamespaces
+        );
+        if (!resolvedCold || deadlineExpired()) {
+          resolvedAmbiguousSeeds.set(result.path, null);
+          return null;
+        }
+        resolvedPath = resolvedCold.result.path;
+        resolvedResult = resolvedCold.result;
+      }
+      if (!path5.isAbsolute(resolvedPath)) {
+        resolvedAmbiguousSeeds.set(result.path, null);
+        return null;
+      }
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        resolvedPath,
+        this.getStorage(),
+        options.recallNamespaces
+      );
+      const ownerNamespace = ownerStorage?.namespace ?? null;
+      const resolved = ownerNamespace && options.recallNamespaces.includes(ownerNamespace) ? { namespace: ownerNamespace, result: resolvedResult } : null;
+      resolvedAmbiguousSeeds.set(result.path, resolved);
+      return resolved;
+    };
+    const coldCollection = config.qmdColdCollection ?? "openclaw-engram-cold";
+    for (const result of options.memoryResults) {
+      if (deadlineExpired()) break;
+      const parts = qmdCollectionPathParts(result.path);
+      if (parts?.collection === coldCollection) {
+        const resolved = await resolveAmbiguousSeedOwner(result, parts);
+        if (resolved) {
+          addResultForNamespace(resolved.namespace, resolved.result);
+        }
+        continue;
+      }
+      if (path5.isAbsolute(result.path)) {
+        const resolved = await resolveAmbiguousSeedOwner(result, null);
+        if (resolved) {
+          addResultForNamespace(resolved.namespace, resolved.result);
+        }
+        continue;
+      }
+      const ns = this.namespaceFromPath(result.path);
+      if (!options.recallNamespaces.includes(ns)) continue;
+      addResultForNamespace(ns, result);
+    }
+    const perNamespaceSeedCap = Math.max(3, options.recallResultLimit);
+    const perNamespaceExpandedCap = Math.max(8, options.recallResultLimit * 2);
+    const seedPaths = [];
+    const seedResults = [];
+    const expandedPaths = [];
+    const expandedResults = [];
+    for (const [namespace, nsResults] of byNamespace.entries()) {
+      if (deadlineExpired()) break;
+      const storage = await this.storageFor(namespace);
+      const seedCandidates = nsResults.slice(0, perNamespaceSeedCap);
+      seedResults.push(...seedCandidates);
+      const seedRelativePaths = typeof options.deadlineAtMs === "number" ? await this.graphSeedPathsWithinDeadline(
+        storage,
+        seedCandidates,
+        options.deadlineAtMs,
+        [namespace]
+      ) : (await Promise.all(
+        seedCandidates.map(
+          (result) => this.graphSeedPathRelativeToStorage(storage, result, [
+            namespace
+          ])
+        )
+      )).filter(
+        (value) => typeof value === "string" && value.length > 0
+      );
+      if (deadlineExpired()) break;
+      if (seedRelativePaths.length === 0) continue;
+      const seedRecallScore = seedCandidates.reduce(
+        (max, item) => Math.max(max, item.score),
+        0
+      );
+      seedPaths.push(
+        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
+      );
+      const seedSet = new Set(seedRelativePaths);
+      const expanded = await this.graphIndexFor(storage).spreadingActivation(
+        seedRelativePaths,
+        config.maxGraphTraversalSteps,
+        {
+          ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
+          ...typeof options.deadlineAtMs === "number" ? { deadlineAtMs: options.deadlineAtMs } : {}
+        }
+      );
+      if (expanded.length === 0) continue;
+      if (deadlineExpired()) break;
+      for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
+        if (deadlineExpired()) break;
+        if (seedSet.has(candidate.path)) continue;
+        const memoryPath = path5.resolve(storage.dir, candidate.path);
+        const memory = await storage.readMemoryByPath(memoryPath);
+        if (deadlineExpired()) break;
+        if (!memory) continue;
+        if (/(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(memory.path)) continue;
+        if (memory.frontmatter.status && memory.frontmatter.status !== "active")
+          continue;
+        const snippet = memory.content.slice(0, 400);
+        const score = blendGraphExpandedRecallScore({
+          graphActivationScore: candidate.score,
+          seedRecallScore,
+          activationWeight: config.graphExpansionActivationWeight,
+          blendMin: config.graphExpansionBlendMin,
+          blendMax: config.graphExpansionBlendMax
+        });
+        expandedResults.push({
+          docid: memory.frontmatter.id,
+          path: memory.path,
+          snippet,
+          score
+        });
+        expandedPaths.push({
+          path: memory.path,
+          score,
+          namespace,
+          seed: path5.resolve(storage.dir, candidate.seed),
+          hopDepth: candidate.hopDepth,
+          decayedWeight: candidate.decayedWeight,
+          graphType: candidate.graphType,
+          // Issue #681 PR 3/3 — surface the per-edge confidence used for
+          // PageRank weighting / floor pruning so downstream observability
+          // (recall_xray, memory_graph_explain) can attribute ranking and
+          // pruning decisions to specific edges.
+          edgeConfidence: candidate.edgeConfidence
+        });
+      }
+    }
+    return {
+      merged: mergeGraphExpandedResults(options.memoryResults, expandedResults),
+      seedPaths,
+      expandedPaths,
+      seedResults
+    };
+  }
+  async recordLastGraphRecallSnapshot(options) {
+    try {
+      const snapshotPath = path5.join(
+        options.storage.dir,
+        "state",
+        "last_graph_recall.json"
+      );
+      await mkdir2(path5.dirname(snapshotPath), { recursive: true });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const totalSeedCount = options.seedPaths.length;
+      const totalExpandedCount = options.expandedPaths.length;
+      const seeds = options.seedPaths.slice(0, 64);
+      const expanded = clampGraphRecallExpandedEntries(
+        options.expandedPaths,
+        64
+      );
+      const payload = {
+        recordedAt: now,
+        mode: options.recallMode,
+        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
+        queryLength: options.prompt.length,
+        namespaces: options.recallNamespaces,
+        seedCount: totalSeedCount,
+        expandedCount: totalExpandedCount,
+        seeds,
+        expanded,
+        status: options.status,
+        reason: options.reason,
+        shadowMode: options.shadowMode === true,
+        queryIntent: options.queryIntent,
+        seedResults: (options.seedResults ?? []).slice(0, 64),
+        finalResults: (options.finalResults ?? []).slice(0, 64),
+        shadowComparison: options.shadowComparison
+      };
+      await writeFile2(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+    } catch (err) {
+      log.debug(`last graph recall write failed: ${err}`);
+    }
+  }
+  async graphSeedPathRelativeToStorage(storage, result, recallNamespaces = []) {
+    const parts = qmdCollectionPathParts(result.path);
+    if (parts) {
+      const memory = await this.readQmdResultMemory(
+        result.path,
+        storage,
+        recallNamespaces
+      );
+      return memory ? graphPathRelativeToStorage(storage.dir, memory.path) : null;
+    }
+    return graphPathRelativeToStorage(storage.dir, result.path);
+  }
+  async graphSeedPathsWithinDeadline(storage, results, deadlineAtMs, recallNamespaces = []) {
+    const resolved = [];
+    for (const result of results) {
+      if (Date.now() >= deadlineAtMs) break;
+      const seedPath = await this.graphSeedPathRelativeToStorage(
+        storage,
+        result,
+        recallNamespaces
+      );
+      if (Date.now() >= deadlineAtMs) break;
+      if (seedPath) resolved.push(seedPath);
+    }
+    return resolved;
+  }
+};
+
+// src/maintenance/pattern-reinforcement.ts
+function patternReinforcementKey(content) {
+  return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
+}
+function patternReinforcementClusterKey(category, content) {
+  return `${category}::${patternReinforcementKey(content)}`;
+}
+function pickCanonical(memories) {
+  let best = memories[0];
+  let bestInstant = memoryInstant(best);
+  let bestStamp = memoryStamp(best);
+  for (let i = 1; i < memories.length; i += 1) {
+    const candidate = memories[i];
+    const instant = memoryInstant(candidate);
+    const stamp = memoryStamp(candidate);
+    let cmp;
+    if (instant !== null && bestInstant !== null) {
+      cmp = instant - bestInstant;
+    } else {
+      cmp = stamp.localeCompare(bestStamp);
+    }
+    if (cmp > 0 || cmp === 0 && candidate.frontmatter.id > best.frontmatter.id) {
+      best = candidate;
+      bestInstant = instant;
+      bestStamp = stamp;
+    }
+  }
+  return best;
+}
+function memoryStamp(memory) {
+  return memory.frontmatter.updated || memory.frontmatter.created || "";
+}
+function memoryInstant(memory) {
+  const stamp = memoryStamp(memory);
+  if (stamp.length === 0) return null;
+  const parsed = Date.parse(stamp);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var ACTIVE_STATUS = "active";
+async function runPatternReinforcement(storage, options) {
+  const minCount = Math.max(2, Math.floor(options.minCount));
+  const targetCategories = new Set(options.categories);
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const nowIso = now().toISOString();
+  if (targetCategories.size === 0) {
+    return emptyResult();
+  }
+  const memories = await storage.readAllMemories();
+  const eligible = memories.filter((m) => {
+    if (!targetCategories.has(m.frontmatter.category)) return false;
+    const status = m.frontmatter.status ?? ACTIVE_STATUS;
+    return status === ACTIVE_STATUS || status === "superseded";
+  });
+  if (eligible.length === 0) return emptyResult();
+  const clusters = clusterByKey(
+    eligible,
+    (m) => patternReinforcementClusterKey(m.frontmatter.category, m.content)
   );
   const result = {
     clustersFound: 0,
@@ -2974,8 +3637,8 @@ function generateResolverDocument(taxonomy) {
 }
 
 // src/taxonomy/taxonomy-loader.ts
-import { readFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+import { readFile, mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -3073,7 +3736,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path6.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile(taxonomyPath, "utf-8");
@@ -3123,16 +3786,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path5.join(memoryDir, TAXONOMY_DIR);
-  await mkdir2(dir, { recursive: true });
-  const filePath = path5.join(dir, TAXONOMY_FILE);
-  await writeFile2(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
+  const dir = path6.join(memoryDir, TAXONOMY_DIR);
+  await mkdir3(dir, { recursive: true });
+  const filePath = path6.join(dir, TAXONOMY_FILE);
+  await writeFile3(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path5.join(memoryDir, TAXONOMY_DIR);
+  return path6.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path6.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/wearables/registry.ts
@@ -4142,11 +4805,11 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path6.join(os2.homedir(), ".openclaw", "workspace");
+  return path7.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const hash = createHash2("sha256").update(sessionKey).digest("hex").slice(0, 12);
+  const hash = createHash3("sha256").update(sessionKey).digest("hex").slice(0, 12);
   return `${readable}-${hash}`;
 }
 function latestSourceValidAtFromTurns(turns) {
@@ -4404,42 +5067,6 @@ function computeQmdHybridFetchLimit(recallFetchLimit, artifactsEnabled, maxArtif
   const artifactHeadroom = Math.max(20, Math.max(0, maxArtifactRecall) * 8);
   return Math.min(400, cappedRecallLimit + artifactHeadroom);
 }
-function mergeGraphExpandedResults(primary, expanded) {
-  const mergedByPath = /* @__PURE__ */ new Map();
-  for (const item of [...primary, ...expanded]) {
-    const prev = mergedByPath.get(item.path);
-    if (!prev) {
-      mergedByPath.set(item.path, item);
-      continue;
-    }
-    const better = item.score > prev.score ? item : prev;
-    const snippet = prev.snippet || item.snippet;
-    mergedByPath.set(item.path, { ...better, snippet });
-  }
-  return Array.from(mergedByPath.values());
-}
-function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path6.isAbsolute(candidatePath) ? candidatePath : path6.resolve(storageDir, candidatePath);
-  const rel = path6.relative(storageDir, absolutePath);
-  if (!rel || rel === ".") return null;
-  if (rel.startsWith("..")) return null;
-  return rel.split(path6.sep).join("/");
-}
-function normalizeGraphActivationScore(score) {
-  const bounded = Number.isFinite(score) && score > 0 ? score : 0;
-  return bounded / (1 + bounded);
-}
-function blendGraphExpandedRecallScore(options) {
-  const graphNorm = normalizeGraphActivationScore(options.graphActivationScore);
-  const seedScore = Number.isFinite(options.seedRecallScore) ? Math.min(1, Math.max(0, options.seedRecallScore)) : 0;
-  const weight = Math.min(1, Math.max(0, options.activationWeight));
-  const rawMin = Math.min(1, Math.max(0, options.blendMin));
-  const rawMax = Math.min(1, Math.max(0, options.blendMax));
-  const minBound = Math.min(rawMin, rawMax);
-  const maxBound = Math.max(rawMin, rawMax);
-  const blended = graphNorm * weight + seedScore * (1 - weight);
-  return Math.max(minBound, Math.min(maxBound, blended));
-}
 function summarizeGraphShadowComparison(baseline, merged, topN) {
   const limit = Math.max(0, Math.floor(topN));
   const baselineTop = limit > 0 ? baseline.slice(0, limit) : [];
@@ -4568,7 +5195,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path6.relative(storageDir, mem.path));
+    pathById.set(id, path7.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -4576,7 +5203,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path6.join(options.storageDir, options.memoryRelPath),
+    path: path7.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -4596,16 +5223,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path6.join("corrections", `${options.memoryId}.md`);
+    return path7.join("corrections", `${options.memoryId}.md`);
   }
   const subtree = categoryDirName(options.category);
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path6.join(subtree, day, `${options.memoryId}.md`);
+    return path7.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path6.join(subtree, `${options.memoryId}.md`);
+  return path7.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -4767,7 +5394,10 @@ var Orchestrator = class _Orchestrator {
    */
   conversationIndexCoordinator;
   recallRerankCoordinator;
+  recallSectionCoordinator;
   qmdResultResolver;
+  contradictionLinkingCoordinator;
+  graphRecallCoordinator;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
@@ -5060,7 +5690,7 @@ var Orchestrator = class _Orchestrator {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path6.resolve(storageDir);
+    const resolvedStorageDir = path7.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -5071,21 +5701,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path6.resolve(storageDir);
-    const resolvedMemoryDir = path6.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path7.resolve(storageDir);
+    const resolvedMemoryDir = path7.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path6.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path7.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path6.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path6.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path7.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path7.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path6.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path7.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path6.basename(resolvedStorageDir);
+    const leaf = path7.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -5113,7 +5743,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path6.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path7.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -5150,7 +5780,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path6.resolve(record.storageDir);
+      const resolvedStorageDir = path7.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -5414,7 +6044,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path6.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path7.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -5484,7 +6114,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = resolveConsolidationCapabilities(config).compounding ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path6.join(
+    this.conversationIndexDir = path7.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -5500,7 +6130,30 @@ var Orchestrator = class _Orchestrator {
       getStorage: (namespace) => this.getStorage(namespace),
       readQmdResultMemory: (resultPath, fallbackStorage, recallNamespaces) => this.readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces)
     });
+    this.recallSectionCoordinator = new RecallSectionCoordinator({
+      getConfig: () => this.config,
+      resolveSectionEnabled: (id, def) => this.isRecallSectionEnabled(id, def)
+    });
+    this.contradictionLinkingCoordinator = new ContradictionLinkingCoordinator({
+      getConfig: () => this.config,
+      isSearchAvailable: () => this.isSearchAvailableForNamespaceRouting(),
+      searchAcrossNamespaces: (options) => this.searchAcrossNamespaces(options),
+      extractMemoryIdsFromResults: (results) => this.extractMemoryIdsFromResults(results),
+      namespaceFromPath: (p) => this.namespaceFromPath(p),
+      storageForNamespace: (namespace) => this.storageRouter.storageFor(namespace),
+      getExtraction: () => this.extraction
+    });
     this.modelRegistry = new ModelRegistry(config.memoryDir);
+    this.graphRecallCoordinator = new GraphRecallCoordinator({
+      getConfig: () => this.config,
+      getStorage: () => this.storage,
+      storageFor: (namespace) => this.storageRouter.storageFor(namespace),
+      graphIndexFor: (storage) => this.graphIndexFor(storage),
+      namespaceFromPath: (p) => this.namespaceFromPath(p),
+      resolveColdQmdResultForRecall: (result, fallbackStorage, recallNamespaces) => this.resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces),
+      storageForAbsoluteQmdResultPath: (resultPath, fallbackStorage, recallNamespaces) => this.storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces),
+      readQmdResultMemory: (resultPath, fallbackStorage, recallNamespaces) => this.readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces)
+    });
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
     this.lastRecall = new LastRecallStore(config.memoryDir);
@@ -5597,7 +6250,7 @@ var Orchestrator = class _Orchestrator {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path6.join(config.memoryDir, "threads"),
+      path7.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -5677,7 +6330,7 @@ var Orchestrator = class _Orchestrator {
       utilityPromoteThresholdDelta: this.utilityRuntimeValues?.promoteThresholdDelta ?? 0,
       utilityDemoteThresholdDelta: this.utilityRuntimeValues?.demoteThresholdDelta ?? 0
     };
-    return createHash2("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
+    return createHash3("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
   }
   effectiveLifecycleThresholds() {
     const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
@@ -5920,7 +6573,7 @@ var Orchestrator = class _Orchestrator {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path6.join(wsDir, f);
+            const fp = path7.join(wsDir, f);
             const s = await stat(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink(fp).catch(() => {
@@ -6115,7 +6768,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-GQ3UQNIL.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-4I3VDSYS.js");
         const result = await runFirstStartMigration({
           storage: this.storage,
           config: this.config,
@@ -6429,15 +7082,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path6.isAbsolute(rel) ? rel : path6.join(this.config.workspaceDir, rel);
+        const abs = path7.isAbsolute(rel) ? rel : path7.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path6.join(
+            const archiveDir = path7.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path6.basename(abs);
+            const base = path7.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -6445,7 +7098,7 @@ ${doc.content}` : doc.content,
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile3(abs, newContent, "utf-8");
+            await writeFile4(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -6462,8 +7115,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path6.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir3(path6.dirname(fp), { recursive: true });
+        const fp = path7.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir4(path7.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -6476,7 +7129,7 @@ ${doc.content}` : doc.content,
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile3(fp, existing + block, "utf-8");
+        await writeFile4(fp, existing + block, "utf-8");
       }
     }
   }
@@ -6602,7 +7255,7 @@ ${doc.content}` : doc.content,
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path6.join(storage.dir, categoryDir, date);
+        const dateDir = path7.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -6611,7 +7264,7 @@ ${doc.content}` : doc.content,
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path6.join(dateDir, entry.name);
+            const fullPath = path7.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile2(fullPath, "utf-8");
@@ -6633,7 +7286,7 @@ ${doc.content}` : doc.content,
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path6.basename(entry.name, ".md"),
+                  id: fm.id || path7.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -6656,13 +7309,13 @@ ${doc.content}` : doc.content,
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path6.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path7.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir2(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path6.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path7.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -6766,7 +7419,7 @@ ${doc.content}` : doc.content,
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path6.join(
+    const snapshotPath = path7.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -6805,7 +7458,7 @@ ${doc.content}` : doc.content,
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path6.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path7.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -6838,7 +7491,7 @@ ${doc.content}` : doc.content,
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path6.join(
+    const snapshotPath = path7.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -7540,7 +8193,7 @@ ${doc.content}` : doc.content,
       if (!options.onDebugSnapshot) return;
       await options.onDebugSnapshot({
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        queryHash: createHash2("sha256").update(prompt).digest("hex"),
+        queryHash: createHash3("sha256").update(prompt).digest("hex"),
         queryLength: prompt.length,
         collection: options.collection,
         namespaces: options.recallNamespaces,
@@ -7645,259 +8298,69 @@ ${doc.content}` : doc.content,
       if (scopedSeedResults.length > 0) {
         const mergedByPath = /* @__PURE__ */ new Map();
         for (const result of [...scopedSeedResults, ...mergedResults]) {
-          const key = result.path || result.docid;
-          const existing = mergedByPath.get(key);
-          if (!existing || result.score > existing.score) {
-            mergedByPath.set(key, {
-              ...result,
-              snippet: result.snippet || existing?.snippet || ""
-            });
-          }
-        }
-        mergedResults = [...mergedByPath.values()].sort((a, b) => b.score - a.score).slice(0, fetchLimit);
-      }
-      const filteredResults = filterRecallCandidates(mergedResults, {
-        namespacesEnabled: options.namespacesEnabled,
-        recallNamespaces: options.recallNamespaces,
-        resolveNamespace: options.resolveNamespace,
-        limit: fetchLimit
-      });
-      if (filteredResults.length >= qmdFetchLimit) {
-        const capped2 = filteredResults.slice(0, qmdFetchLimit);
-        await emitDebugSnapshot(capped2, fetchLimit);
-        return capped2;
-      }
-      if (filteredResults.length > bestFiltered.length) {
-        bestFiltered = filteredResults;
-      }
-      if (mergedResults.length === 0) {
-        await emitDebugSnapshot(filteredResults, fetchLimit);
-        return filteredResults;
-      }
-      if (mergedResults.length < fetchLimit && filteredResults.length > 0) {
-        await emitDebugSnapshot(filteredResults, fetchLimit);
-        return filteredResults;
-      }
-      if (fetchLimit >= maxFetchLimit) {
-        break;
-      }
-      const growth = Math.max(20, Math.floor(fetchLimit / 2));
-      fetchLimit = Math.min(maxFetchLimit, fetchLimit + growth);
-    }
-    const capped = bestFiltered.slice(0, qmdFetchLimit);
-    await emitDebugSnapshot(capped, fetchLimit);
-    return capped;
-  }
-  async expandResultsViaGraph(options) {
-    const deadlineExpired = () => typeof options.deadlineAtMs === "number" && Date.now() >= options.deadlineAtMs;
-    const byNamespace = /* @__PURE__ */ new Map();
-    const addResultForNamespace = (namespace, result) => {
-      const existing = byNamespace.get(namespace);
-      if (existing) {
-        existing.push(result);
-      } else {
-        byNamespace.set(namespace, [result]);
-      }
-    };
-    const resolvedAmbiguousSeeds = /* @__PURE__ */ new Map();
-    const resolveAmbiguousSeedOwner = async (result, parts) => {
-      const cached = resolvedAmbiguousSeeds.get(result.path);
-      if (cached !== void 0) return cached;
-      if (deadlineExpired()) {
-        resolvedAmbiguousSeeds.set(result.path, null);
-        return null;
-      }
-      let resolvedPath = result.path;
-      let resolvedResult = result;
-      if (parts) {
-        const resolvedCold = await this.resolveColdQmdResultForRecall(
-          result,
-          this.storage,
-          options.recallNamespaces
-        );
-        if (!resolvedCold || deadlineExpired()) {
-          resolvedAmbiguousSeeds.set(result.path, null);
-          return null;
-        }
-        resolvedPath = resolvedCold.result.path;
-        resolvedResult = resolvedCold.result;
-      }
-      if (!path6.isAbsolute(resolvedPath)) {
-        resolvedAmbiguousSeeds.set(result.path, null);
-        return null;
-      }
-      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        resolvedPath,
-        this.storage,
-        options.recallNamespaces
-      );
-      const ownerNamespace = ownerStorage?.namespace ?? null;
-      const resolved = ownerNamespace && options.recallNamespaces.includes(ownerNamespace) ? { namespace: ownerNamespace, result: resolvedResult } : null;
-      resolvedAmbiguousSeeds.set(result.path, resolved);
-      return resolved;
-    };
-    const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
-    for (const result of options.memoryResults) {
-      if (deadlineExpired()) break;
-      const parts = qmdCollectionPathParts(result.path);
-      if (parts?.collection === coldCollection) {
-        const resolved = await resolveAmbiguousSeedOwner(result, parts);
-        if (resolved) {
-          addResultForNamespace(resolved.namespace, resolved.result);
-        }
-        continue;
-      }
-      if (path6.isAbsolute(result.path)) {
-        const resolved = await resolveAmbiguousSeedOwner(result, null);
-        if (resolved) {
-          addResultForNamespace(resolved.namespace, resolved.result);
-        }
-        continue;
-      }
-      const ns = this.namespaceFromPath(result.path);
-      if (!options.recallNamespaces.includes(ns)) continue;
-      addResultForNamespace(ns, result);
-    }
-    const perNamespaceSeedCap = Math.max(3, options.recallResultLimit);
-    const perNamespaceExpandedCap = Math.max(8, options.recallResultLimit * 2);
-    const seedPaths = [];
-    const seedResults = [];
-    const expandedPaths = [];
-    const expandedResults = [];
-    for (const [namespace, nsResults] of byNamespace.entries()) {
-      if (deadlineExpired()) break;
-      const storage = await this.storageRouter.storageFor(namespace);
-      const seedCandidates = nsResults.slice(0, perNamespaceSeedCap);
-      seedResults.push(...seedCandidates);
-      const seedRelativePaths = typeof options.deadlineAtMs === "number" ? await this.graphSeedPathsWithinDeadline(
-        storage,
-        seedCandidates,
-        options.deadlineAtMs,
-        [namespace]
-      ) : (await Promise.all(
-        seedCandidates.map(
-          (result) => this.graphSeedPathRelativeToStorage(storage, result, [
-            namespace
-          ])
-        )
-      )).filter(
-        (value) => typeof value === "string" && value.length > 0
-      );
-      if (deadlineExpired()) break;
-      if (seedRelativePaths.length === 0) continue;
-      const seedRecallScore = seedCandidates.reduce(
-        (max, item) => Math.max(max, item.score),
-        0
-      );
-      seedPaths.push(
-        ...seedRelativePaths.map((rel) => path6.join(storage.dir, rel))
-      );
-      const seedSet = new Set(seedRelativePaths);
-      const expanded = await this.graphIndexFor(storage).spreadingActivation(
-        seedRelativePaths,
-        this.config.maxGraphTraversalSteps,
-        {
-          ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
-          ...typeof options.deadlineAtMs === "number" ? { deadlineAtMs: options.deadlineAtMs } : {}
-        }
-      );
-      if (expanded.length === 0) continue;
-      if (deadlineExpired()) break;
-      for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
-        if (deadlineExpired()) break;
-        if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path6.resolve(storage.dir, candidate.path);
-        const memory = await storage.readMemoryByPath(memoryPath);
-        if (deadlineExpired()) break;
-        if (!memory) continue;
-        if (isArtifactMemoryPath(memory.path)) continue;
-        if (memory.frontmatter.status && memory.frontmatter.status !== "active")
-          continue;
-        const snippet = memory.content.slice(0, 400);
-        const score = blendGraphExpandedRecallScore({
-          graphActivationScore: candidate.score,
-          seedRecallScore,
-          activationWeight: this.config.graphExpansionActivationWeight,
-          blendMin: this.config.graphExpansionBlendMin,
-          blendMax: this.config.graphExpansionBlendMax
-        });
-        expandedResults.push({
-          docid: memory.frontmatter.id,
-          path: memory.path,
-          snippet,
-          score
-        });
-        expandedPaths.push({
-          path: memory.path,
-          score,
-          namespace,
-          seed: path6.resolve(storage.dir, candidate.seed),
-          hopDepth: candidate.hopDepth,
-          decayedWeight: candidate.decayedWeight,
-          graphType: candidate.graphType,
-          // Issue #681 PR 3/3 — surface the per-edge confidence used for
-          // PageRank weighting / floor pruning so downstream observability
-          // (recall_xray, memory_graph_explain) can attribute ranking and
-          // pruning decisions to specific edges.
-          edgeConfidence: candidate.edgeConfidence
-        });
+          const key = result.path || result.docid;
+          const existing = mergedByPath.get(key);
+          if (!existing || result.score > existing.score) {
+            mergedByPath.set(key, {
+              ...result,
+              snippet: result.snippet || existing?.snippet || ""
+            });
+          }
+        }
+        mergedResults = [...mergedByPath.values()].sort((a, b) => b.score - a.score).slice(0, fetchLimit);
+      }
+      const filteredResults = filterRecallCandidates(mergedResults, {
+        namespacesEnabled: options.namespacesEnabled,
+        recallNamespaces: options.recallNamespaces,
+        resolveNamespace: options.resolveNamespace,
+        limit: fetchLimit
+      });
+      if (filteredResults.length >= qmdFetchLimit) {
+        const capped2 = filteredResults.slice(0, qmdFetchLimit);
+        await emitDebugSnapshot(capped2, fetchLimit);
+        return capped2;
+      }
+      if (filteredResults.length > bestFiltered.length) {
+        bestFiltered = filteredResults;
+      }
+      if (mergedResults.length === 0) {
+        await emitDebugSnapshot(filteredResults, fetchLimit);
+        return filteredResults;
+      }
+      if (mergedResults.length < fetchLimit && filteredResults.length > 0) {
+        await emitDebugSnapshot(filteredResults, fetchLimit);
+        return filteredResults;
       }
+      if (fetchLimit >= maxFetchLimit) {
+        break;
+      }
+      const growth = Math.max(20, Math.floor(fetchLimit / 2));
+      fetchLimit = Math.min(maxFetchLimit, fetchLimit + growth);
     }
-    return {
-      merged: mergeGraphExpandedResults(options.memoryResults, expandedResults),
-      seedPaths,
-      expandedPaths,
-      seedResults
-    };
+    const capped = bestFiltered.slice(0, qmdFetchLimit);
+    await emitDebugSnapshot(capped, fetchLimit);
+    return capped;
+  }
+  // Issue #1526 (seam 14): graph-recall expansion moved to
+  // GraphRecallCoordinator. Thin delegation keeps the private API stable
+  // for callers (recallInternal, cold-fallback pipeline) + tests.
+  async expandResultsViaGraph(options) {
+    return this.graphRecallCoordinator.expandResultsViaGraph(options);
   }
+  // Issue #1526 (seam 14): graph-recall snapshot moved to
+  // GraphRecallCoordinator. Thin delegation keeps the private API stable.
   async recordLastGraphRecallSnapshot(options) {
-    try {
-      const snapshotPath = path6.join(
-        options.storage.dir,
-        "state",
-        "last_graph_recall.json"
-      );
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const totalSeedCount = options.seedPaths.length;
-      const totalExpandedCount = options.expandedPaths.length;
-      const seeds = options.seedPaths.slice(0, 64);
-      const expanded = clampGraphRecallExpandedEntries(
-        options.expandedPaths,
-        64
-      );
-      const payload = {
-        recordedAt: now,
-        mode: options.recallMode,
-        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
-        queryLength: options.prompt.length,
-        namespaces: options.recallNamespaces,
-        seedCount: totalSeedCount,
-        expandedCount: totalExpandedCount,
-        seeds,
-        expanded,
-        status: options.status,
-        reason: options.reason,
-        shadowMode: options.shadowMode === true,
-        queryIntent: options.queryIntent,
-        seedResults: (options.seedResults ?? []).slice(0, 64),
-        finalResults: (options.finalResults ?? []).slice(0, 64),
-        shadowComparison: options.shadowComparison
-      };
-      await writeFile3(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
-    } catch (err) {
-      log.debug(`last graph recall write failed: ${err}`);
-    }
+    return this.graphRecallCoordinator.recordLastGraphRecallSnapshot(options);
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path6.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir4(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -7908,233 +8371,111 @@ ${doc.content}` : doc.content,
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path6.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
-        snapshotPath,
-        JSON.stringify(options.snapshot, null, 2),
-        "utf-8"
-      );
-    } catch (err) {
-      log.debug(`last qmd recall write failed: ${err}`);
-    }
-  }
-  async recordLastIntentSnapshotForNamespace(options) {
-    try {
-      const stateDir = await this.resolveStateDirForNamespace(
-        options.namespace
-      );
-      const snapshotPath = path6.join(stateDir, "last_intent.json");
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir4(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
       );
-    } catch (err) {
-      log.debug(`last intent write failed: ${err}`);
-    }
-  }
-  async resolveStateDirForNamespace(namespace) {
-    if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path6.join(this.config.memoryDir, "state");
-    }
-    if (namespace !== this.config.defaultNamespace) {
-      return path6.join(this.config.memoryDir, "namespaces", namespace, "state");
-    }
-    const candidate = path6.join(
-      this.config.memoryDir,
-      "namespaces",
-      this.config.defaultNamespace
-    );
-    try {
-      const candidateStat = await stat(candidate);
-      if (candidateStat.isDirectory()) {
-        return path6.join(candidate, "state");
-      }
-    } catch {
-    }
-    return path6.join(this.config.memoryDir, "state");
-  }
-  buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
-    return results.slice(0, limit).map((result) => ({
-      path: result.path,
-      score: result.score,
-      docid: result.docid,
-      sourceLabels: sourceLabelResolver(result.path)
-    }));
-  }
-  getRecallSectionEntry(sectionId) {
-    const pipeline = Array.isArray(this.config.recallPipeline) ? this.config.recallPipeline : [];
-    return pipeline.find((entry) => entry.id === sectionId);
-  }
-  isRecallSectionEnabled(sectionId, defaultEnabled = true) {
-    const entry = this.getRecallSectionEntry(sectionId);
-    if (!entry) return defaultEnabled;
-    return entry.enabled !== false;
-  }
-  isSpecializedRecallSectionEnabled(sectionId, topLevelEnabled) {
-    const entry = this.getRecallSectionEntry(sectionId);
-    if (!entry) return topLevelEnabled;
-    return entry.enabled === true || topLevelEnabled && entry.enabled !== false;
-  }
-  getRecallSectionMaxChars(sectionId) {
-    const entry = this.getRecallSectionEntry(sectionId);
-    if (!entry) return void 0;
-    if (entry.maxChars === null) return null;
-    if (typeof entry.maxChars !== "number") return void 0;
-    return Math.max(0, Math.floor(entry.maxChars));
-  }
-  getRecallSectionNumber(sectionId, key) {
-    const entry = this.getRecallSectionEntry(sectionId);
-    if (!entry) return void 0;
-    const value = entry[key];
-    if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
-    return Math.max(0, Math.floor(value));
-  }
-  appendRecallSection(sectionBuckets, sectionId, content) {
-    if (!this.isRecallSectionEnabled(sectionId)) return false;
-    const trimmed = content.trim();
-    if (trimmed.length === 0) return false;
-    const maxChars = this.getRecallSectionMaxChars(sectionId);
-    let finalContent = trimmed;
-    if (maxChars === 0) return false;
-    if (typeof maxChars === "number" && finalContent.length > maxChars) {
-      finalContent = `${finalContent.slice(0, maxChars)}
-
-...(trimmed)
-`;
-    }
-    const existing = sectionBuckets.get(sectionId) ?? [];
-    existing.push(finalContent);
-    sectionBuckets.set(sectionId, existing);
-    return true;
-  }
-  truncateRecallSectionToBudget(content, maxChars) {
-    if (maxChars <= 0) return "";
-    if (content.length <= maxChars) return content;
-    const suffix = "\n\n...(memory context trimmed)";
-    if (maxChars <= suffix.length) {
-      return content.slice(0, maxChars);
-    }
-    return `${content.slice(0, maxChars - suffix.length)}${suffix}`;
-  }
-  protectedRecallSectionIds(sectionBuckets) {
-    const protectedIds = /* @__PURE__ */ new Set();
-    if ((sectionBuckets.get("memories")?.length ?? 0) > 0) {
-      protectedIds.add("memories");
-    }
-    return protectedIds;
-  }
-  protectedRecallReservationChars(content) {
-    const headingBoundary = content.indexOf("\n\n");
-    const headingChars = headingBoundary >= 0 ? headingBoundary + 2 : Math.min(content.length, 24);
-    return Math.min(content.length, Math.max(headingChars, 24));
-  }
-  estimateReservedRecallBudget(entries, startIndex, protectedIds, alreadyIncludedCount) {
-    const separatorLength = "\n\n---\n\n".length;
-    let reserved = 0;
-    let simulatedIncluded = alreadyIncludedCount;
-    for (let i = startIndex; i < entries.length; i += 1) {
-      const entry = entries[i];
-      if (!entry || !protectedIds.has(entry.id)) continue;
-      if (simulatedIncluded > 0) {
-        reserved += separatorLength;
-      }
-      reserved += this.protectedRecallReservationChars(entry.content);
-      simulatedIncluded += 1;
-    }
-    return reserved;
-  }
-  getRecallBudgetChars(override) {
-    if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
-      return Math.floor(override);
-    }
-    const configuredBudget = this.config.recallBudgetChars;
-    if (typeof configuredBudget === "number" && Number.isFinite(configuredBudget) && configuredBudget >= 0) {
-      return Math.floor(configuredBudget);
-    }
-    const tokenBudget = this.config.maxMemoryTokens;
-    if (typeof tokenBudget === "number" && Number.isFinite(tokenBudget) && tokenBudget >= 0) {
-      return Math.floor(tokenBudget * 4);
-    }
-    return 0;
-  }
-  assembleRecallSections(sectionBuckets, budgetOverride) {
-    const orderedEntries = [];
-    const pipeline = Array.isArray(this.config.recallPipeline) ? this.config.recallPipeline : [];
-    const orderedIds = pipeline.filter((entry) => entry.enabled !== false).map((entry) => entry.id);
-    const seen = /* @__PURE__ */ new Set();
-    for (const id of orderedIds) {
-      const chunks = sectionBuckets.get(id);
-      if (!chunks || chunks.length === 0) continue;
-      orderedEntries.push({ id, content: chunks.join("\n\n") });
-      seen.add(id);
-    }
-    for (const [id, chunks] of sectionBuckets.entries()) {
-      if (seen.has(id)) continue;
-      if (chunks.length === 0) continue;
-      orderedEntries.push({ id, content: chunks.join("\n\n") });
-    }
-    const budget = this.getRecallBudgetChars(budgetOverride);
-    if (budget === 0) {
-      return {
-        sections: [],
-        includedIds: [],
-        omittedIds: orderedEntries.map((entry) => entry.id),
-        truncated: orderedEntries.length > 0,
-        finalChars: 0
-      };
-    }
-    const separator = "\n\n---\n\n";
-    const protectedIds = this.protectedRecallSectionIds(sectionBuckets);
-    const sections = [];
-    const includedIds = [];
-    const omittedIds = [];
-    let usedChars = 0;
-    let truncated = false;
-    for (let index = 0; index < orderedEntries.length; index += 1) {
-      const entry = orderedEntries[index];
-      const separatorChars = sections.length > 0 ? separator.length : 0;
-      const reserve = protectedIds.has(entry.id) ? 0 : this.estimateReservedRecallBudget(
-        orderedEntries,
-        index + 1,
-        protectedIds,
-        sections.length + 1
-      );
-      const availableForEntry = budget - usedChars - separatorChars - reserve;
-      if (availableForEntry <= 0) {
-        omittedIds.push(entry.id);
-        truncated = true;
-        continue;
-      }
-      const finalContent = this.truncateRecallSectionToBudget(
-        entry.content,
-        availableForEntry
+    } catch (err) {
+      log.debug(`last qmd recall write failed: ${err}`);
+    }
+  }
+  async recordLastIntentSnapshotForNamespace(options) {
+    try {
+      const stateDir = await this.resolveStateDirForNamespace(
+        options.namespace
       );
-      if (!finalContent) {
-        omittedIds.push(entry.id);
-        truncated = true;
-        continue;
-      }
-      if (finalContent.length < entry.content.length) {
-        truncated = true;
+      const snapshotPath = path7.join(stateDir, "last_intent.json");
+      await mkdir4(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
+        snapshotPath,
+        JSON.stringify(options.snapshot, null, 2),
+        "utf-8"
+      );
+    } catch (err) {
+      log.debug(`last intent write failed: ${err}`);
+    }
+  }
+  async resolveStateDirForNamespace(namespace) {
+    if (!resolveNamespaceCapabilities(this.config).namespaces) {
+      return path7.join(this.config.memoryDir, "state");
+    }
+    if (namespace !== this.config.defaultNamespace) {
+      return path7.join(this.config.memoryDir, "namespaces", namespace, "state");
+    }
+    const candidate = path7.join(
+      this.config.memoryDir,
+      "namespaces",
+      this.config.defaultNamespace
+    );
+    try {
+      const candidateStat = await stat(candidate);
+      if (candidateStat.isDirectory()) {
+        return path7.join(candidate, "state");
       }
-      sections.push(finalContent);
-      includedIds.push(entry.id);
-      usedChars += separatorChars + finalContent.length;
+    } catch {
     }
-    return {
-      sections,
-      includedIds,
-      omittedIds,
-      truncated,
-      finalChars: usedChars
-    };
+    return path7.join(this.config.memoryDir, "state");
+  }
+  buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
+    return results.slice(0, limit).map((result) => ({
+      path: result.path,
+      score: result.score,
+      docid: result.docid,
+      sourceLabels: sourceLabelResolver(result.path)
+    }));
+  }
+  // Issue #1526 (seam 13): recall section budgeting/assembly moved to
+  // RecallSectionCoordinator. Thin delegation keeps the orchestrator's
+  // recallInternal call sites stable.
+  getRecallSectionEntry(sectionId) {
+    return this.recallSectionCoordinator.getRecallSectionEntry(sectionId);
+  }
+  isRecallSectionEnabled(sectionId, defaultEnabled = true) {
+    return this.recallSectionCoordinator.isRecallSectionEnabled(
+      sectionId,
+      defaultEnabled
+    );
+  }
+  isSpecializedRecallSectionEnabled(sectionId, topLevelEnabled) {
+    return this.recallSectionCoordinator.isSpecializedRecallSectionEnabled(
+      sectionId,
+      topLevelEnabled
+    );
+  }
+  getRecallSectionMaxChars(sectionId) {
+    return this.recallSectionCoordinator.getRecallSectionMaxChars(sectionId);
+  }
+  getRecallSectionNumber(sectionId, key) {
+    return this.recallSectionCoordinator.getRecallSectionNumber(sectionId, key);
+  }
+  appendRecallSection(sectionBuckets, sectionId, content) {
+    return this.recallSectionCoordinator.appendRecallSection(
+      sectionBuckets,
+      sectionId,
+      content
+    );
+  }
+  truncateRecallSectionToBudget(content, maxChars) {
+    return this.recallSectionCoordinator.truncateRecallSectionToBudget(
+      content,
+      maxChars
+    );
+  }
+  getRecallBudgetChars(override) {
+    return this.recallSectionCoordinator.getRecallBudgetChars(override);
+  }
+  assembleRecallSections(sectionBuckets, budgetOverride) {
+    return this.recallSectionCoordinator.assembleRecallSections(
+      sectionBuckets,
+      budgetOverride
+    );
   }
   /**
    * Clock source for the shared post-retrieval assembly/enrichment budget. The
@@ -8211,8 +8552,8 @@ ${doc.content}` : doc.content,
         timings,
         logger: log
       });
-      const promptHash = createHash2("sha256").update(prompt).digest("hex");
-      const traceId = createHash2("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
+      const promptHash = createHash3("sha256").update(prompt).digest("hex");
+      const traceId = createHash3("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
       const sectionBuckets = /* @__PURE__ */ new Map();
       const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
         cronRecallPolicyEnabled: resolveRecallAuxiliaryCapabilities(this.config).cronRecallPolicy,
@@ -8221,7 +8562,7 @@ ${doc.content}` : doc.content,
         cronConversationRecallMode: this.config.cronConversationRecallMode
       });
       const retrievalQuery = queryPolicy.retrievalQuery || prompt;
-      const retrievalQueryHash = createHash2("sha256").update(retrievalQuery).digest("hex");
+      const retrievalQueryHash = createHash3("sha256").update(retrievalQuery).digest("hex");
       const policyVersion = this.currentPolicyVersion();
       let impressionRecorded = false;
       let recallSource = "none";
@@ -8360,7 +8701,7 @@ ${doc.content}` : doc.content,
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path6.sep).join("/");
+        const normalizedPath = resultPath.split(path7.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -8510,7 +8851,7 @@ ${doc.content}` : doc.content,
         profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path6.join(this.config.memoryDir, ".empty-scope-profile") },
+        { dir: path7.join(this.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -9986,11 +10327,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path6.join(
+        const signalPath = path7.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path6.join(workspaceDir, "BOOT.md");
+        const bootPath = path7.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -12261,7 +12602,7 @@ _Context: ${topQuestion.context}_`
     const shouldUseStableBatchKey = turns.some(
       (turn) => turn.persistProcessedFingerprint === true || typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0
     );
-    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash2("sha256").update(
+    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash3("sha256").update(
       turns.map(
         (turn) => [
           turn.role,
@@ -12511,7 +12852,7 @@ _Context: ${topQuestion.context}_`
   buildExtractionFingerprint(turns, bufferKey) {
     const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
     if (!normalized) return null;
-    return createHash2("sha256").update(`${bufferKey}
+    return createHash3("sha256").update(`${bufferKey}
 ${normalized}`).digest("hex");
   }
   shouldQueueExtraction(turns, options = {}) {
@@ -14592,7 +14933,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path6.relative(storage.dir, m.path);
+            const rel = path7.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -14916,7 +15257,7 @@ ${normalized}`).digest("hex");
     }
     if (resolveConsolidationCapabilities(this.config).semanticConsolidation) {
       try {
-        const stateFilePath = path6.join(
+        const stateFilePath = path7.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -14964,9 +15305,9 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path6.join(this.config.memoryDir, "state");
-            await mkdir3(stateDir, { recursive: true });
-            await writeFile3(
+            const stateDir = path7.join(this.config.memoryDir, "state");
+            await mkdir4(stateDir, { recursive: true });
+            await writeFile4(
               stateFilePath,
               JSON.stringify({ lastRunAt: (/* @__PURE__ */ new Date()).toISOString() }),
               "utf-8"
@@ -15304,30 +15645,13 @@ ${reflectionsContent.trim()}
     return this.recallRerankCoordinator.applyMmrToQmdResults(sectionId, results, caps);
   }
   buildLastRecallBudgetSummary(options) {
-    return {
-      requestedTopK: options.requestedTopK,
-      appliedTopK: options.recallResultLimit,
-      recallBudgetChars: this.getRecallBudgetChars(),
-      maxMemoryTokens: this.config.maxMemoryTokens,
-      qmdFetchLimit: options.qmdFetchLimit,
-      qmdHybridFetchLimit: options.qmdHybridFetchLimit,
-      finalContextChars: options.finalContextChars,
-      truncated: options.truncated,
-      includedSections: [...options.includedSections ?? []],
-      omittedSections: [...options.omittedSections ?? []]
-    };
+    return this.recallSectionCoordinator.buildLastRecallBudgetSummary(options);
   }
   collectLastRecallSources(sectionBuckets, recallSource) {
-    const used = /* @__PURE__ */ new Set();
-    if (recallSource !== "none") {
-      used.add(recallSource);
-    }
-    for (const [sectionId, chunks] of sectionBuckets.entries()) {
-      if (chunks.length > 0) {
-        used.add(sectionId);
-      }
-    }
-    return [...used];
+    return this.recallSectionCoordinator.collectLastRecallSources(
+      sectionBuckets,
+      recallSource
+    );
   }
   /**
    * Issue #373 — nearest-neighbor lookup for the write-time semantic dedup
@@ -15377,12 +15701,12 @@ ${reflectionsContent.trim()}
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path6.resolve(this.config.memoryDir);
-    const storageDir = path6.resolve(targetStorage.dir);
+    const memoryDir = path7.resolve(this.config.memoryDir);
+    const storageDir = path7.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path6.relative(memoryDir, storageDir);
+    let rel = path7.relative(memoryDir, storageDir);
     if (!rel || rel.startsWith("..")) {
       log.debug(
         `semantic dedup: target storage dir ${storageDir} is outside memoryDir ${memoryDir}; scoping lookup to absolute path prefix`
@@ -15401,7 +15725,7 @@ ${reflectionsContent.trim()}
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path6.isAbsolute(hit.path) ? hit.path : path6.join(this.config.memoryDir, hit.path);
+      const fullPath = path7.isAbsolute(hit.path) ? hit.path : path7.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -15598,7 +15922,7 @@ ${reflectionsContent.trim()}
           const storage = await this.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path6.resolve(storageDir);
+          const recallRoot = path7.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -15622,8 +15946,8 @@ ${reflectionsContent.trim()}
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path6.isAbsolute(result.path)) {
-          const resolvedPath = path6.resolve(result.path);
+        if (path7.isAbsolute(result.path)) {
+          const resolvedPath = path7.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -16289,58 +16613,11 @@ ${reflectionsContent.trim()}
    * Uses QMD to find similar memories, then LLM to verify contradiction.
    */
   async checkForContradiction(content, category, namespaceScope) {
-    if (!this.isSearchAvailableForNamespaceRouting()) return null;
-    const results = await this.searchAcrossNamespaces({
-      query: content,
-      namespaces: [namespaceScope],
-      maxResults: 5,
-      mode: "search"
-    });
-    for (const result of results) {
-      if (result.score < this.config.contradictionSimilarityThreshold) {
-        continue;
-      }
-      const memoryId = this.extractMemoryIdsFromResults([result])[0];
-      if (!memoryId) continue;
-      const resultNamespace = this.namespaceFromPath(result.path);
-      if (resultNamespace !== namespaceScope) continue;
-      const resultStorage = await this.storageRouter.storageFor(resultNamespace);
-      const existingMemory = await resultStorage.getMemoryById(memoryId);
-      if (!existingMemory) continue;
-      if (existingMemory.frontmatter.status === "superseded" || existingMemory.frontmatter.status === "forgotten") {
-        continue;
-      }
-      const verification = await this.extraction.verifyContradiction(
-        { content, category },
-        {
-          id: existingMemory.frontmatter.id,
-          content: existingMemory.content,
-          category: existingMemory.frontmatter.category,
-          created: existingMemory.frontmatter.created
-        }
-      );
-      if (!verification) continue;
-      if (verification.isContradiction && verification.confidence >= this.config.contradictionMinConfidence) {
-        if (verification.whichIsNewer === "first") {
-          log.info(
-            `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory \u2014 existing is newer, incoming fact is stale`
-          );
-          continue;
-        }
-        log.info(
-          `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory${this.config.contradictionAutoResolve ? " (auto-resolved)" : " (queued for manual review)"}`
-        );
-        return {
-          supersededId: existingMemory.frontmatter.id,
-          confidence: verification.confidence,
-          reason: verification.reasoning,
-          supersededPath: existingMemory.path,
-          supersededCreated: existingMemory.frontmatter.created,
-          supersededTags: existingMemory.frontmatter.tags ?? []
-        };
-      }
-    }
-    return null;
+    return this.contradictionLinkingCoordinator.checkForContradiction(
+      content,
+      category,
+      namespaceScope
+    );
   }
   /**
    * #1645: Complete the deferred contradiction auto-resolve after writeMemory
@@ -16351,40 +16628,12 @@ ${reflectionsContent.trim()}
    * supersedes before tombstone status is known" defect class.
    */
   async applyDeferredContradictionResolve(contradiction, storage, newMemoryId, postWriteGuard) {
-    if (postWriteGuard && contradiction && this.config.contradictionAutoResolve) {
-      try {
-        const blockedRow = await storage.getMemoryById(newMemoryId);
-        if (blockedRow?.frontmatter?.supersedes) {
-          await storage.writeMemoryFrontmatter(blockedRow, { supersedes: void 0 });
-        }
-      } catch (err) {
-        log.warn(
-          `contradiction auto-resolve supersedes clear failed for blocked ${newMemoryId}: ${err}`
-        );
-      }
-    }
-    if (!contradiction || !this.config.contradictionAutoResolve || postWriteGuard) {
-      return;
-    }
-    try {
-      await storage.supersedeMemory(
-        contradiction.supersededId,
-        newMemoryId,
-        contradiction.reason
-      );
-      if (resolveIndexingCapabilities(this.config).queryAwareIndexing && contradiction.supersededPath) {
-        deindexMemory(
-          this.config.memoryDir,
-          contradiction.supersededPath,
-          contradiction.supersededCreated,
-          contradiction.supersededTags
-        );
-      }
-    } catch (err) {
-      log.warn(
-        `contradiction auto-resolve supersede failed for ${contradiction.supersededId}: ${err}`
-      );
-    }
+    return this.contradictionLinkingCoordinator.applyDeferredContradictionResolve(
+      contradiction,
+      storage,
+      newMemoryId,
+      postWriteGuard
+    );
   }
   // ---------------------------------------------------------------------------
   // Memory Linking (Phase 3A)
@@ -16393,68 +16642,11 @@ ${reflectionsContent.trim()}
    * Suggest links for a new memory based on similar existing memories.
    */
   async suggestLinksForMemory(content, category, namespaceScope) {
-    if (!this.isSearchAvailableForNamespaceRouting()) return [];
-    const results = await this.searchAcrossNamespaces({
-      query: content,
-      namespaces: [namespaceScope],
-      maxResults: 5,
-      mode: "search"
-    });
-    if (results.length === 0) return [];
-    const candidates = [];
-    for (const result of results) {
-      const memoryId = this.extractMemoryIdsFromResults([result])[0];
-      if (!memoryId) continue;
-      const resultNamespace = this.namespaceFromPath(result.path);
-      if (resultNamespace !== namespaceScope) continue;
-      const resultStorage = await this.storageRouter.storageFor(resultNamespace);
-      const memory = await resultStorage.getMemoryById(memoryId);
-      if (memory && memory.frontmatter.status !== "superseded" && memory.frontmatter.status !== "forgotten") {
-        candidates.push({
-          id: memory.frontmatter.id,
-          content: memory.content,
-          category: memory.frontmatter.category
-        });
-      }
-    }
-    if (candidates.length === 0) return [];
-    const suggestions = await this.extraction.suggestLinks(
-      { content, category },
-      candidates
+    return this.contradictionLinkingCoordinator.suggestLinksForMemory(
+      content,
+      category,
+      namespaceScope
     );
-    if (!suggestions || suggestions.links.length === 0) return [];
-    return suggestions.links.map((link) => ({
-      targetId: link.targetId,
-      linkType: link.linkType,
-      strength: link.strength,
-      reason: link.reason || void 0
-    }));
-  }
-  async graphSeedPathRelativeToStorage(storage, result, recallNamespaces = []) {
-    const parts = qmdCollectionPathParts(result.path);
-    if (parts) {
-      const memory = await this.readQmdResultMemory(
-        result.path,
-        storage,
-        recallNamespaces
-      );
-      return memory ? graphPathRelativeToStorage(storage.dir, memory.path) : null;
-    }
-    return graphPathRelativeToStorage(storage.dir, result.path);
-  }
-  async graphSeedPathsWithinDeadline(storage, results, deadlineAtMs, recallNamespaces = []) {
-    const resolved = [];
-    for (const result of results) {
-      if (Date.now() >= deadlineAtMs) break;
-      const seedPath = await this.graphSeedPathRelativeToStorage(
-        storage,
-        result,
-        recallNamespaces
-      );
-      if (Date.now() >= deadlineAtMs) break;
-      if (seedPath) resolved.push(seedPath);
-    }
-    return resolved;
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return this.config.defaultNamespace;
@@ -16515,6 +16707,9 @@ export {
   buildProcedureRecallSection,
   hasIdentityRecoveryIntent,
   resolveEffectiveIdentityInjectionMode,
+  mergeGraphExpandedResults,
+  graphPathRelativeToStorage,
+  blendGraphExpandedRecallScore,
   decideSemanticDedup,
   DEFAULT_TAXONOMY,
   generateResolverDocument,
@@ -16546,9 +16741,6 @@ export {
   resolveRecallModeDecisionAsync,
   computeArtifactCandidateFetchLimit,
   computeQmdHybridFetchLimit,
-  mergeGraphExpandedResults,
-  graphPathRelativeToStorage,
-  blendGraphExpandedRecallScore,
   summarizeGraphShadowComparison,
   mergeArtifactRecallCandidates,
   resolveRecentThreadMemoryPaths,
@@ -16557,4 +16749,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-7HUGLMSW.js.map
+//# sourceMappingURL=chunk-SODQQCAZ.js.map