@remnic/core 9.3.741 → 9.3.743

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

@@ -4,13 +4,13 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-OZECYVGI.js";
+} 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";
@@ -19,7 +19,7 @@ import {
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-773DPI6T.js";
+} from "./chunk-V5RVMULT.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.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,7 +512,7 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path5 from "path";
+import path6 from "path";
 import os2 from "os";
 import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
@@ -2196,7 +2196,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path6, c] of nsMap) counters.set(path6, c);
+        for (const [path7, c] of nsMap) counters.set(path7, 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 (path6) => {
+        readMemoryFrontmatter: async (path7) => {
           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(path6, fallbackReader, namespaces);
+          const memory = await this.readQmdResultMemory(path7, fallbackReader, namespaces);
           return memory ? memory.frontmatter : null;
         }
       },
@@ -2391,214 +2391,839 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
   }
 };
 
-// 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,
-    canonicalsUpdated: 0,
-    duplicatesSuperseded: 0,
-    clusters: []
-  };
-  for (const cluster of clusters.values()) {
-    if (cluster.length < minCount) continue;
-    const activeMembers = cluster.filter((m) => {
-      const status = m.frontmatter.status ?? ACTIVE_STATUS;
-      return status === ACTIVE_STATUS;
-    });
-    if (activeMembers.length === 0) continue;
-    result.clustersFound += 1;
-    const canonical = pickCanonical(activeMembers);
-    const activeDuplicates = activeMembers.filter((m) => m !== canonical);
-    const sourceIds = [...cluster].map((m) => m.frontmatter.id).filter((id) => typeof id === "string" && id.length > 0).sort();
-    const previousCount = canonical.frontmatter.reinforcement_count ?? 0;
-    const newCount = sourceIds.length;
-    const reinforcementBumped = newCount > previousCount;
-    const previousDerivedFrom = Array.isArray(canonical.frontmatter.derived_from) ? [...canonical.frontmatter.derived_from].sort() : [];
-    const sortedSourceIds = [...sourceIds].sort();
-    const membershipChanged = previousDerivedFrom.length !== sortedSourceIds.length || previousDerivedFrom.some((id, i) => id !== sortedSourceIds[i]);
-    const previousVia = canonical.frontmatter.derived_via;
-    const viaChanged = previousVia !== "pattern-reinforcement";
-    const canonicalNeedsRefresh = reinforcementBumped || membershipChanged || viaChanged;
-    if (canonicalNeedsRefresh) {
-      const patch = {
-        derived_from: sourceIds,
-        derived_via: "pattern-reinforcement",
-        updated: nowIso
-      };
-      if (reinforcementBumped) {
-        patch.reinforcement_count = newCount;
-        patch.last_reinforced_at = nowIso;
-      } else {
-        patch.reinforcement_count = canonical.frontmatter.reinforcement_count ?? newCount;
-        patch.last_reinforced_at = canonical.frontmatter.last_reinforced_at ?? nowIso;
-      }
-      await storage.writeMemoryFrontmatter(canonical, patch);
-      result.canonicalsUpdated += 1;
-    }
-    const supersededIds = [];
-    for (const dup of activeDuplicates) {
-      const patch = {
-        status: "superseded",
-        supersededBy: canonical.frontmatter.id,
-        supersededAt: nowIso,
-        updated: nowIso
-      };
-      await storage.writeMemoryFrontmatter(dup, patch);
-      supersededIds.push(dup.frontmatter.id);
-      result.duplicatesSuperseded += 1;
-      if (storage.appendTombstone) {
-        for (const input of buildRetiredFactTombstoneInputs(
-          {
-            id: dup.frontmatter.id,
-            content: dup.content,
-            contentHash: dup.frontmatter.contentHash,
-            entityRef: dup.frontmatter.entityRef,
-            structuredAttributes: dup.frontmatter.structuredAttributes
-          },
-          { reason: "supersession", createdBy: "supersession", createdAt: nowIso, supersessionKeysForFact }
-        )) {
-          try {
-            await storage.appendTombstone(input);
-          } catch {
-          }
-        }
-      }
-    }
-    result.clusters.push({
-      canonicalId: canonical.frontmatter.id,
-      count: newCount,
-      sourceIds,
-      supersededIds,
-      reinforcementBumped
-    });
-  }
-  return result;
-}
-function emptyResult() {
-  return {
-    clustersFound: 0,
-    canonicalsUpdated: 0,
-    duplicatesSuperseded: 0,
-    clusters: []
-  };
-}
-
-// src/dedup/semantic.ts
-var DEFAULT_SEMANTIC_THRESHOLD = 0.92;
-var DEFAULT_SEMANTIC_CANDIDATES = 5;
-function normalizeSemanticThreshold(value) {
-  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : DEFAULT_SEMANTIC_THRESHOLD;
-}
-function normalizeSemanticCandidates(value) {
-  if (!Number.isFinite(value) || value < 0) {
-    return DEFAULT_SEMANTIC_CANDIDATES;
+// 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));
   }
-  const normalized = Math.floor(value);
-  return value > 0 && normalized === 0 ? 1 : normalized;
-}
-async function decideSemanticDedup(content, lookup, options) {
-  if (!options.enabled) {
-    return { action: "keep", reason: "disabled" };
+  getRecallSectionEntry(sectionId) {
+    const pipeline = Array.isArray(this.getConfig().recallPipeline) ? this.getConfig().recallPipeline : [];
+    return pipeline.find((entry) => entry.id === sectionId);
   }
-  const threshold = normalizeSemanticThreshold(options.threshold);
-  const candidates = normalizeSemanticCandidates(options.candidates);
-  if (candidates === 0) {
-    return { action: "keep", reason: "disabled" };
+  isRecallSectionEnabled(sectionId, defaultEnabled = true) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return defaultEnabled;
+    return entry.enabled !== false;
   }
-  const trimmed = typeof content === "string" ? content.trim() : "";
-  if (!trimmed) {
-    return { action: "keep", reason: "no_near_duplicate" };
+  isSpecializedRecallSectionEnabled(sectionId, topLevelEnabled) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return topLevelEnabled;
+    return entry.enabled === true || topLevelEnabled && entry.enabled !== false;
   }
-  let hits = [];
-  try {
-    hits = await lookup(trimmed, candidates);
-  } catch {
-    return { action: "keep", reason: "backend_unavailable" };
+  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));
   }
-  if (!Array.isArray(hits) || hits.length === 0) {
-    return { action: "keep", reason: "no_candidates" };
+  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));
   }
-  let top;
-  for (const hit of hits) {
-    if (!hit || typeof hit.id !== "string" || hit.id.trim().length === 0 || typeof hit.score !== "number" || !Number.isFinite(hit.score)) {
-      continue;
+  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)
+`;
     }
-    if (!top || hit.score > top.score) {
-      top = hit;
+    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}`;
   }
-  if (!top) {
-    return { action: "keep", reason: "no_near_duplicate" };
+  protectedRecallSectionIds(sectionBuckets) {
+    const protectedIds = /* @__PURE__ */ new Set();
+    if ((sectionBuckets.get("memories")?.length ?? 0) > 0) {
+      protectedIds.add("memories");
+    }
+    return protectedIds;
   }
-  if (top.score >= threshold) {
-    return {
-      action: "skip",
-      reason: "near_duplicate",
-      topScore: top.score,
-      topId: top.id,
-      topPath: top.path
-    };
+  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));
   }
-  return {
-    action: "keep",
-    reason: "no_near_duplicate",
-    topScore: top.score,
+  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) {
+  if (!resultPath || path4.isAbsolute(resultPath)) return null;
+  const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
+  const collection = normalized.slice(0, slashIndex);
+  if (/^\d{4}-\d{2}-\d{2}$/.test(collection)) return null;
+  return {
+    collection,
+    relativePath: normalized.slice(slashIndex + 1)
+  };
+}
+function qmdResultPathCandidates(storageDir, resultPath) {
+  const candidates = /* @__PURE__ */ new Set();
+  const storageRoot = path4.resolve(storageDir);
+  const addCandidate = (candidate) => {
+    const resolved = path4.resolve(candidate);
+    if (isPathInsideStorageRoot(storageRoot, resolved)) {
+      candidates.add(resolved);
+    }
+  };
+  const addRelativeCandidates = (relativePath) => {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized) return;
+    addCandidate(path4.join(storageRoot, normalized));
+    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+      addCandidate(path4.join(storageRoot, "facts", normalized));
+    }
+  };
+  if (path4.isAbsolute(resultPath)) {
+    addCandidate(resultPath);
+  } else {
+    addRelativeCandidates(resultPath);
+  }
+  return [...candidates];
+}
+function storageDirOrNull(storage) {
+  const dir = storage.dir;
+  return typeof dir === "string" && dir.length > 0 ? dir : null;
+}
+var QmdResultResolver = class {
+  getConfig;
+  storageFor;
+  storageDirNamespace;
+  qmdCollectionNamespaceFromPrefix;
+  namespaceFromPath;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.storageFor = options.storageFor;
+    this.storageDirNamespace = options.storageDirNamespace;
+    this.qmdCollectionNamespaceFromPrefix = options.qmdCollectionNamespaceFromPrefix;
+    this.namespaceFromPath = options.namespaceFromPath;
+  }
+  async readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces = []) {
+    const parts = qmdCollectionPathParts(resultPath);
+    const fallbackStorageDir = storageDirOrNull(fallbackStorage);
+    const config = this.getConfig();
+    const coldCollection = config.qmdColdCollection ?? "openclaw-engram-cold";
+    if (parts && parts.collection === coldCollection) {
+      const storages = [];
+      const seenStorageDirs = /* @__PURE__ */ new Set();
+      const addStorage = (storage) => {
+        const storageDir = storageDirOrNull(storage);
+        const storageKey = storageDir ? path4.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        if (seenStorageDirs.has(storageKey)) return;
+        seenStorageDirs.add(storageKey);
+        storages.push(storage);
+      };
+      const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
+      if (recallNamespaces.length === 0 || !resolveNamespaceCapabilities(config).namespaces || recallNamespaces.includes(fallbackNamespace)) {
+        addStorage(fallbackStorage);
+      }
+      if (recallNamespaces.length > 0) {
+        for (const namespace of recallNamespaces) {
+          try {
+            addStorage(await this.storageFor(namespace));
+          } catch (err) {
+            log.debug("qmd cold result namespace storage lookup skipped", {
+              path: resultPath,
+              namespace,
+              error: err.message
+            });
+          }
+        }
+      }
+      for (const storage of storages) {
+        const storageDir = storageDirOrNull(storage);
+        if (!storageDir) {
+          const memory = await storage.readMemoryByPath(resultPath);
+          if (memory) return memory;
+          continue;
+        }
+        try {
+          const coldRoot = path4.join(storageDir, "cold");
+          for (const candidate of qmdResultPathCandidates(
+            coldRoot,
+            parts.relativePath
+          )) {
+            const memory = await storage.readMemoryByPath(candidate);
+            if (memory) return memory;
+          }
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError) throw err;
+          log.debug("qmd cold result path lookup failed open", {
+            path: resultPath,
+            collection: coldCollection,
+            error: err.message
+          });
+        }
+      }
+      return null;
+    }
+    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
+    if (parts && collectionNamespace) {
+      try {
+        const collectionStorage = await this.storageFor(collectionNamespace);
+        for (const candidate of qmdResultPathCandidates(
+          collectionStorage.dir,
+          parts.relativePath
+        )) {
+          const memory = await collectionStorage.readMemoryByPath(candidate);
+          if (memory) return memory;
+        }
+        return null;
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) throw err;
+        log.debug("qmd result namespace path lookup failed open", {
+          path: resultPath,
+          namespace: collectionNamespace,
+          error: err.message
+        });
+        return null;
+      }
+    }
+    if (path4.isAbsolute(resultPath)) {
+      if (!fallbackStorageDir) {
+        return await fallbackStorage.readMemoryByPath(resultPath);
+      }
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        resultPath,
+        fallbackStorage,
+        recallNamespaces
+      );
+      if (!ownerStorage) return null;
+      for (const candidate of qmdResultPathCandidates(
+        ownerStorage.dir,
+        resultPath
+      )) {
+        const memory = await ownerStorage.storage.readMemoryByPath(candidate);
+        if (memory) return memory;
+      }
+      return null;
+    }
+    if (!fallbackStorageDir) {
+      return await fallbackStorage.readMemoryByPath(resultPath);
+    }
+    for (const candidate of qmdResultPathCandidates(
+      fallbackStorageDir,
+      resultPath
+    )) {
+      const memory = await fallbackStorage.readMemoryByPath(candidate);
+      if (memory) return memory;
+    }
+    return null;
+  }
+  async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
+    const memory = await this.readQmdResultMemory(
+      result.path,
+      fallbackStorage,
+      recallNamespaces
+    );
+    if (!memory) return null;
+    let ownerNamespace = null;
+    if (path4.isAbsolute(memory.path)) {
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        memory.path,
+        fallbackStorage,
+        recallNamespaces
+      );
+      ownerNamespace = ownerStorage?.namespace ?? null;
+      if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
+    }
+    ownerNamespace ??= this.namespaceFromPath(memory.path);
+    if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
+      return null;
+    }
+    return {
+      namespace: ownerNamespace,
+      result: {
+        ...result,
+        docid: result.docid || memory.frontmatter.id,
+        path: memory.path,
+        snippet: result.snippet || memory.content.slice(0, 400)
+      }
+    };
+  }
+  async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
+    const resolvedPath = path4.resolve(resultPath);
+    const config = this.getConfig();
+    const memoryRoot = path4.resolve(config.memoryDir);
+    const namespacesRoot = path4.join(memoryRoot, "namespaces");
+    const fallbackStorageDir = storageDirOrNull(fallbackStorage);
+    const matches = [];
+    const seenDirs = /* @__PURE__ */ new Set();
+    const maybeAddStorage = (storage, namespace) => {
+      const storageDir = storageDirOrNull(storage);
+      if (!storageDir) return;
+      const candidateRoot = path4.resolve(storageDir);
+      if (seenDirs.has(candidateRoot)) return;
+      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
+      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+        return;
+      }
+      seenDirs.add(candidateRoot);
+      matches.push({ storage, dir: candidateRoot, namespace });
+    };
+    const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
+    maybeAddStorage(fallbackStorage, fallbackNamespace);
+    const candidateNamespaces = /* @__PURE__ */ new Set();
+    candidateNamespaces.add(config.defaultNamespace);
+    candidateNamespaces.add(config.sharedNamespace);
+    for (const ns of recallNamespaces) {
+      candidateNamespaces.add(ns);
+    }
+    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+      const relativeToNamespaces = path4.relative(namespacesRoot, resolvedPath);
+      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
+      if (namespaceSegment) {
+        candidateNamespaces.add(
+          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
+        );
+      }
+    }
+    for (const policy of config.namespacePolicies ?? []) {
+      candidateNamespaces.add(policy.name);
+    }
+    for (const ns of candidateNamespaces) {
+      if (!ns) continue;
+      try {
+        maybeAddStorage(await this.storageFor(ns), ns);
+      } catch {
+        continue;
+      }
+    }
+    matches.sort((a, b) => b.dir.length - a.dir.length);
+    return matches[0] ?? null;
+  }
+};
+
+// 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;
+  }
+  /**
+   * 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/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,
+    canonicalsUpdated: 0,
+    duplicatesSuperseded: 0,
+    clusters: []
+  };
+  for (const cluster of clusters.values()) {
+    if (cluster.length < minCount) continue;
+    const activeMembers = cluster.filter((m) => {
+      const status = m.frontmatter.status ?? ACTIVE_STATUS;
+      return status === ACTIVE_STATUS;
+    });
+    if (activeMembers.length === 0) continue;
+    result.clustersFound += 1;
+    const canonical = pickCanonical(activeMembers);
+    const activeDuplicates = activeMembers.filter((m) => m !== canonical);
+    const sourceIds = [...cluster].map((m) => m.frontmatter.id).filter((id) => typeof id === "string" && id.length > 0).sort();
+    const previousCount = canonical.frontmatter.reinforcement_count ?? 0;
+    const newCount = sourceIds.length;
+    const reinforcementBumped = newCount > previousCount;
+    const previousDerivedFrom = Array.isArray(canonical.frontmatter.derived_from) ? [...canonical.frontmatter.derived_from].sort() : [];
+    const sortedSourceIds = [...sourceIds].sort();
+    const membershipChanged = previousDerivedFrom.length !== sortedSourceIds.length || previousDerivedFrom.some((id, i) => id !== sortedSourceIds[i]);
+    const previousVia = canonical.frontmatter.derived_via;
+    const viaChanged = previousVia !== "pattern-reinforcement";
+    const canonicalNeedsRefresh = reinforcementBumped || membershipChanged || viaChanged;
+    if (canonicalNeedsRefresh) {
+      const patch = {
+        derived_from: sourceIds,
+        derived_via: "pattern-reinforcement",
+        updated: nowIso
+      };
+      if (reinforcementBumped) {
+        patch.reinforcement_count = newCount;
+        patch.last_reinforced_at = nowIso;
+      } else {
+        patch.reinforcement_count = canonical.frontmatter.reinforcement_count ?? newCount;
+        patch.last_reinforced_at = canonical.frontmatter.last_reinforced_at ?? nowIso;
+      }
+      await storage.writeMemoryFrontmatter(canonical, patch);
+      result.canonicalsUpdated += 1;
+    }
+    const supersededIds = [];
+    for (const dup of activeDuplicates) {
+      const patch = {
+        status: "superseded",
+        supersededBy: canonical.frontmatter.id,
+        supersededAt: nowIso,
+        updated: nowIso
+      };
+      await storage.writeMemoryFrontmatter(dup, patch);
+      supersededIds.push(dup.frontmatter.id);
+      result.duplicatesSuperseded += 1;
+      if (storage.appendTombstone) {
+        for (const input of buildRetiredFactTombstoneInputs(
+          {
+            id: dup.frontmatter.id,
+            content: dup.content,
+            contentHash: dup.frontmatter.contentHash,
+            entityRef: dup.frontmatter.entityRef,
+            structuredAttributes: dup.frontmatter.structuredAttributes
+          },
+          { reason: "supersession", createdBy: "supersession", createdAt: nowIso, supersessionKeysForFact }
+        )) {
+          try {
+            await storage.appendTombstone(input);
+          } catch {
+          }
+        }
+      }
+    }
+    result.clusters.push({
+      canonicalId: canonical.frontmatter.id,
+      count: newCount,
+      sourceIds,
+      supersededIds,
+      reinforcementBumped
+    });
+  }
+  return result;
+}
+function emptyResult() {
+  return {
+    clustersFound: 0,
+    canonicalsUpdated: 0,
+    duplicatesSuperseded: 0,
+    clusters: []
+  };
+}
+
+// src/dedup/semantic.ts
+var DEFAULT_SEMANTIC_THRESHOLD = 0.92;
+var DEFAULT_SEMANTIC_CANDIDATES = 5;
+function normalizeSemanticThreshold(value) {
+  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : DEFAULT_SEMANTIC_THRESHOLD;
+}
+function normalizeSemanticCandidates(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    return DEFAULT_SEMANTIC_CANDIDATES;
+  }
+  const normalized = Math.floor(value);
+  return value > 0 && normalized === 0 ? 1 : normalized;
+}
+async function decideSemanticDedup(content, lookup, options) {
+  if (!options.enabled) {
+    return { action: "keep", reason: "disabled" };
+  }
+  const threshold = normalizeSemanticThreshold(options.threshold);
+  const candidates = normalizeSemanticCandidates(options.candidates);
+  if (candidates === 0) {
+    return { action: "keep", reason: "disabled" };
+  }
+  const trimmed = typeof content === "string" ? content.trim() : "";
+  if (!trimmed) {
+    return { action: "keep", reason: "no_near_duplicate" };
+  }
+  let hits = [];
+  try {
+    hits = await lookup(trimmed, candidates);
+  } catch {
+    return { action: "keep", reason: "backend_unavailable" };
+  }
+  if (!Array.isArray(hits) || hits.length === 0) {
+    return { action: "keep", reason: "no_candidates" };
+  }
+  let top;
+  for (const hit of hits) {
+    if (!hit || typeof hit.id !== "string" || hit.id.trim().length === 0 || typeof hit.score !== "number" || !Number.isFinite(hit.score)) {
+      continue;
+    }
+    if (!top || hit.score > top.score) {
+      top = hit;
+    }
+  }
+  if (!top) {
+    return { action: "keep", reason: "no_near_duplicate" };
+  }
+  if (top.score >= threshold) {
+    return {
+      action: "skip",
+      reason: "near_duplicate",
+      topScore: top.score,
+      topId: top.id,
+      topPath: top.path
+    };
+  }
+  return {
+    action: "keep",
+    reason: "no_near_duplicate",
+    topScore: top.score,
     topId: top.id
   };
 }
@@ -2724,7 +3349,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -2822,7 +3447,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path4.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile(taxonomyPath, "utf-8");
@@ -2872,16 +3497,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path4.join(memoryDir, TAXONOMY_DIR);
+  const dir = path5.join(memoryDir, TAXONOMY_DIR);
   await mkdir2(dir, { recursive: true });
-  const filePath = path4.join(dir, TAXONOMY_FILE);
+  const filePath = path5.join(dir, TAXONOMY_FILE);
   await writeFile2(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path4.join(memoryDir, TAXONOMY_DIR);
+  return path5.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path4.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/wearables/registry.ts
@@ -3781,42 +4406,6 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
     }
   }
 }
-function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path5.isAbsolute(resultPath)) return null;
-  const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
-  const slashIndex = normalized.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
-  const collection = normalized.slice(0, slashIndex);
-  if (/^\d{4}-\d{2}-\d{2}$/.test(collection)) return null;
-  return {
-    collection,
-    relativePath: normalized.slice(slashIndex + 1)
-  };
-}
-function qmdResultPathCandidates(storageDir, resultPath) {
-  const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path5.resolve(storageDir);
-  const addCandidate = (candidate) => {
-    const resolved = path5.resolve(candidate);
-    if (isPathInsideStorageRoot(storageRoot, resolved)) {
-      candidates.add(resolved);
-    }
-  };
-  const addRelativeCandidates = (relativePath) => {
-    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
-    if (!normalized) return;
-    addCandidate(path5.join(storageRoot, normalized));
-    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path5.join(storageRoot, "facts", normalized));
-    }
-  };
-  if (path5.isAbsolute(resultPath)) {
-    addCandidate(resultPath);
-  } else {
-    addRelativeCandidates(resultPath);
-  }
-  return [...candidates];
-}
 var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
 var DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 1e4;
 function normalizeIanaTimeZone(value) {
@@ -3927,7 +4516,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path5.join(os2.homedir(), ".openclaw", "workspace");
+  return path6.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -4204,11 +4793,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   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);
+  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(path5.sep).join("/");
+  return rel.split(path6.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -4353,7 +4942,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path5.relative(storageDir, mem.path));
+    pathById.set(id, path6.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -4361,7 +4950,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path5.join(options.storageDir, options.memoryRelPath),
+    path: path6.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -4381,16 +4970,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path5.join("corrections", `${options.memoryId}.md`);
+    return path6.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 path5.join(subtree, day, `${options.memoryId}.md`);
+    return path6.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path5.join(subtree, `${options.memoryId}.md`);
+  return path6.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -4552,6 +5141,9 @@ var Orchestrator = class _Orchestrator {
    */
   conversationIndexCoordinator;
   recallRerankCoordinator;
+  recallSectionCoordinator;
+  qmdResultResolver;
+  contradictionLinkingCoordinator;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
@@ -4844,7 +5436,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 = path5.resolve(storageDir);
+    const resolvedStorageDir = path6.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -4855,21 +5447,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path5.resolve(storageDir);
-    const resolvedMemoryDir = path5.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path6.resolve(storageDir);
+    const resolvedMemoryDir = path6.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path5.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path6.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path5.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path5.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path6.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path6.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path5.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path6.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path5.basename(resolvedStorageDir);
+    const leaf = path6.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -4897,7 +5489,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path5.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path6.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -4934,7 +5526,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path5.resolve(record.storageDir);
+      const resolvedStorageDir = path6.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -5198,7 +5790,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path5.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path6.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -5268,7 +5860,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 = path5.join(
+    this.conversationIndexDir = path6.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -5284,6 +5876,19 @@ 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.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -5310,6 +5915,13 @@ var Orchestrator = class _Orchestrator {
       getStorage: (namespace) => this.getStorage(namespace),
       fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options)
     });
+    this.qmdResultResolver = new QmdResultResolver({
+      getConfig: () => this.config,
+      storageFor: (namespace) => this.storageRouter.storageFor(namespace),
+      storageDirNamespace: (storageDir) => this.storageDirNamespace(storageDir),
+      qmdCollectionNamespaceFromPrefix: (prefix) => this.qmdCollectionNamespaceFromPrefix(prefix),
+      namespaceFromPath: (p) => this.namespaceFromPath(p)
+    });
     this.sessionObserver = new SessionObserverState({
       memoryDir: config.memoryDir,
       debounceMs: config.sessionObserverDebounceMs ?? 12e4,
@@ -5374,7 +5986,7 @@ var Orchestrator = class _Orchestrator {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path5.join(config.memoryDir, "threads"),
+      path6.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -5697,7 +6309,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 = path5.join(wsDir, f);
+            const fp = path6.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(() => {
@@ -5892,7 +6504,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,
@@ -5915,7 +6527,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (!this.wearablesAutoSyncHandle && this.config.wearables.enabled && this.config.wearables.autoSyncEnabled && Object.values(this.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-G3V5AN4C.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-XHSKKQAH.js");
         if (signal.aborted) return;
         this.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -6206,15 +6818,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path5.isAbsolute(rel) ? rel : path5.join(this.config.workspaceDir, rel);
+        const abs = path6.isAbsolute(rel) ? rel : path6.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path5.join(
+            const archiveDir = path6.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path5.basename(abs);
+            const base = path6.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -6239,8 +6851,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path5.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir3(path5.dirname(fp), { recursive: true });
+        const fp = path6.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir3(path6.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -6379,7 +6991,7 @@ ${doc.content}` : doc.content,
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path5.join(storage.dir, categoryDir, date);
+        const dateDir = path6.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -6388,7 +7000,7 @@ ${doc.content}` : doc.content,
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path5.join(dateDir, entry.name);
+            const fullPath = path6.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile2(fullPath, "utf-8");
@@ -6410,7 +7022,7 @@ ${doc.content}` : doc.content,
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path5.basename(entry.name, ".md"),
+                  id: fm.id || path6.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -6433,13 +7045,13 @@ ${doc.content}` : doc.content,
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path5.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path6.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 = path5.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path6.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -6543,7 +7155,7 @@ ${doc.content}` : doc.content,
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(
+    const snapshotPath = path6.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -6582,7 +7194,7 @@ ${doc.content}` : doc.content,
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path6.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -6615,7 +7227,7 @@ ${doc.content}` : doc.content,
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(
+    const snapshotPath = path6.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -7499,7 +8111,7 @@ ${doc.content}` : doc.content,
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path5.isAbsolute(resolvedPath)) {
+      if (!path6.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -7524,7 +8136,7 @@ ${doc.content}` : doc.content,
         }
         continue;
       }
-      if (path5.isAbsolute(result.path)) {
+      if (path6.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -7567,7 +8179,7 @@ ${doc.content}` : doc.content,
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path6.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -7583,7 +8195,7 @@ ${doc.content}` : doc.content,
       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 memoryPath = path6.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (deadlineExpired()) break;
         if (!memory) continue;
@@ -7608,7 +8220,7 @@ ${doc.content}` : doc.content,
           path: memory.path,
           score,
           namespace,
-          seed: path5.resolve(storage.dir, candidate.seed),
+          seed: path6.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -7629,12 +8241,12 @@ ${doc.content}` : doc.content,
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -7668,12 +8280,12 @@ ${doc.content}` : doc.content,
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7685,12 +8297,12 @@ ${doc.content}` : doc.content,
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7705,8 +8317,8 @@ ${doc.content}` : doc.content,
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path5.join(stateDir, "last_intent.json");
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path6.join(stateDir, "last_intent.json");
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7718,12 +8330,12 @@ ${doc.content}` : doc.content,
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path5.join(this.config.memoryDir, "state");
+      return path6.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path5.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path6.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path5.join(
+    const candidate = path6.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -7731,11 +8343,11 @@ ${doc.content}` : doc.content,
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path5.join(candidate, "state");
+        return path6.join(candidate, "state");
       }
     } catch {
     }
-    return path5.join(this.config.memoryDir, "state");
+    return path6.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -7745,173 +8357,51 @@ ${doc.content}` : doc.content,
       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) {
-    const pipeline = Array.isArray(this.config.recallPipeline) ? this.config.recallPipeline : [];
-    return pipeline.find((entry) => entry.id === sectionId);
+    return this.recallSectionCoordinator.getRecallSectionEntry(sectionId);
   }
   isRecallSectionEnabled(sectionId, defaultEnabled = true) {
-    const entry = this.getRecallSectionEntry(sectionId);
-    if (!entry) return defaultEnabled;
-    return entry.enabled !== false;
+    return this.recallSectionCoordinator.isRecallSectionEnabled(
+      sectionId,
+      defaultEnabled
+    );
   }
   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;
+    return this.recallSectionCoordinator.isSpecializedRecallSectionEnabled(
+      sectionId,
+      topLevelEnabled
+    );
   }
-  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}`;
+  getRecallSectionMaxChars(sectionId) {
+    return this.recallSectionCoordinator.getRecallSectionMaxChars(sectionId);
   }
-  protectedRecallSectionIds(sectionBuckets) {
-    const protectedIds = /* @__PURE__ */ new Set();
-    if ((sectionBuckets.get("memories")?.length ?? 0) > 0) {
-      protectedIds.add("memories");
-    }
-    return protectedIds;
+  getRecallSectionNumber(sectionId, key) {
+    return this.recallSectionCoordinator.getRecallSectionNumber(sectionId, key);
   }
-  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));
+  appendRecallSection(sectionBuckets, sectionId, content) {
+    return this.recallSectionCoordinator.appendRecallSection(
+      sectionBuckets,
+      sectionId,
+      content
+    );
   }
-  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;
+  truncateRecallSectionToBudget(content, maxChars) {
+    return this.recallSectionCoordinator.truncateRecallSectionToBudget(
+      content,
+      maxChars
+    );
   }
   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;
+    return this.recallSectionCoordinator.getRecallBudgetChars(override);
   }
   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
-      );
-      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
-    };
+    return this.recallSectionCoordinator.assembleRecallSections(
+      sectionBuckets,
+      budgetOverride
+    );
   }
   /**
    * Clock source for the shared post-retrieval assembly/enrichment budget. The
@@ -8137,7 +8627,7 @@ ${doc.content}` : doc.content,
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path5.sep).join("/");
+        const normalizedPath = resultPath.split(path6.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -8287,7 +8777,7 @@ ${doc.content}` : doc.content,
         profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path5.join(this.config.memoryDir, ".empty-scope-profile") },
+        { dir: path6.join(this.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -9763,11 +10253,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path5.join(
+        const signalPath = path6.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path5.join(workspaceDir, "BOOT.md");
+        const bootPath = path6.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -14369,7 +14859,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path5.relative(storage.dir, m.path);
+            const rel = path6.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -14693,7 +15183,7 @@ ${normalized}`).digest("hex");
     }
     if (resolveConsolidationCapabilities(this.config).semanticConsolidation) {
       try {
-        const stateFilePath = path5.join(
+        const stateFilePath = path6.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -14741,7 +15231,7 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path5.join(this.config.memoryDir, "state");
+            const stateDir = path6.join(this.config.memoryDir, "state");
             await mkdir3(stateDir, { recursive: true });
             await writeFile3(
               stateFilePath,
@@ -15003,247 +15493,65 @@ ${reflectionsContent.trim()}
     if (!resolveEvalCapabilities(this.config).evalHarness || !resolveEvalCapabilities(this.config).evalShadowMode)
       return;
     this.evalShadowWriteChain = this.evalShadowWriteChain.catch(() => void 0).then(async () => {
-      try {
-        await recordEvalShadowRecall({
-          memoryDir: this.config.memoryDir,
-          evalStoreDir: this.config.evalStoreDir,
-          record: {
-            schemaVersion: 1,
-            ...record
-          }
-        });
-      } catch (err) {
-        log.debug(`eval shadow recall write failed: ${err}`);
-      }
-    });
-  }
-  publishRecallResults(options) {
-    const sectionId = "memories";
-    const trustByPath = options.trustByPath ?? null;
-    const injectable = trustByPath ? options.results.filter((r) => !trustByPath.get(r.path)?.quarantined) : options.results;
-    const memoryIds = this.extractMemoryIdsFromResults(injectable);
-    this.trackMemoryAccess(memoryIds);
-    this.appendRecallSection(
-      options.sectionBuckets,
-      sectionId,
-      this.formatQmdResults(options.title, injectable, options.sessionKey, trustByPath)
-    );
-  }
-  /**
-   * Apply MMR over the pre-truncation recall candidate pool and then slice
-   * the result to `limit`. This is the single place in the pipeline where
-   * MMR runs, and it must be called *before* callers throw away candidates
-   * that would otherwise sit below the final cutoff. Running MMR post-slice
-   * is a no-op in the cases we care about — diverse candidates just below
-   * the cutoff are already gone and can never be promoted.
-   *
-   * Callers must pass the full candidate pool (post-rerank, pre-slice).
-   */
-  qmdCollectionNamespaceFromPrefix(collectionPrefix) {
-    const baseCollection = this.config.qmdCollection;
-    if (collectionPrefix === baseCollection) return this.config.defaultNamespace;
-    const namespaceSuffix = collectionPrefix.startsWith(`${baseCollection}--`) ? collectionPrefix.slice(baseCollection.length + 2) : "";
-    if (!namespaceSuffix) return null;
-    const decoded = namespaceIdentityFromToken(namespaceSuffix);
-    if (decoded !== null) return decoded || this.config.defaultNamespace;
-    if (namespaceSuffix.startsWith("ns--")) {
-      const legacyNamespace = namespaceSuffix.slice("ns--".length).trim();
-      return legacyNamespace || null;
-    }
-    return null;
-  }
-  async readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces = []) {
-    const parts = qmdCollectionPathParts(resultPath);
-    const storageDirFor = (storage) => typeof storage.dir === "string" && storage.dir ? storage.dir : null;
-    const fallbackStorageDir = storageDirFor(fallbackStorage);
-    const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
-    if (parts && parts.collection === coldCollection) {
-      const storages = [];
-      const seenStorageDirs = /* @__PURE__ */ new Set();
-      const addStorage = (storage) => {
-        const storageDir = storageDirFor(storage);
-        const storageKey = storageDir ? path5.resolve(storageDir) : `storage-without-dir-${storages.length}`;
-        if (seenStorageDirs.has(storageKey)) return;
-        seenStorageDirs.add(storageKey);
-        storages.push(storage);
-      };
-      const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : this.config.defaultNamespace;
-      if (recallNamespaces.length === 0 || !resolveNamespaceCapabilities(this.config).namespaces || recallNamespaces.includes(fallbackNamespace)) {
-        addStorage(fallbackStorage);
-      }
-      if (recallNamespaces.length > 0) {
-        for (const namespace of recallNamespaces) {
-          try {
-            addStorage(await this.storageRouter.storageFor(namespace));
-          } catch (err) {
-            log.debug("qmd cold result namespace storage lookup skipped", {
-              path: resultPath,
-              namespace,
-              error: err.message
-            });
-          }
-        }
-      }
-      for (const storage of storages) {
-        const storageDir = storageDirFor(storage);
-        if (!storageDir) {
-          const memory = await storage.readMemoryByPath(resultPath);
-          if (memory) return memory;
-          continue;
-        }
-        try {
-          const coldRoot = path5.join(storageDir, "cold");
-          for (const candidate of qmdResultPathCandidates(
-            coldRoot,
-            parts.relativePath
-          )) {
-            const memory = await storage.readMemoryByPath(candidate);
-            if (memory) return memory;
-          }
-        } catch (err) {
-          if (err instanceof SecureStoreLockedError) throw err;
-          log.debug("qmd cold result path lookup failed open", {
-            path: resultPath,
-            collection: coldCollection,
-            error: err.message
-          });
-        }
-      }
-      return null;
-    }
-    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
-    if (parts && collectionNamespace) {
-      try {
-        const collectionStorage = await this.storageRouter.storageFor(collectionNamespace);
-        for (const candidate of qmdResultPathCandidates(
-          collectionStorage.dir,
-          parts.relativePath
-        )) {
-          const memory = await collectionStorage.readMemoryByPath(candidate);
-          if (memory) return memory;
-        }
-        return null;
-      } catch (err) {
-        if (err instanceof SecureStoreLockedError) throw err;
-        log.debug("qmd result namespace path lookup failed open", {
-          path: resultPath,
-          namespace: collectionNamespace,
-          error: err.message
-        });
-        return null;
-      }
-    }
-    if (path5.isAbsolute(resultPath)) {
-      if (!fallbackStorageDir) {
-        return await fallbackStorage.readMemoryByPath(resultPath);
-      }
-      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        resultPath,
-        fallbackStorage,
-        recallNamespaces
-      );
-      if (!ownerStorage) return null;
-      for (const candidate of qmdResultPathCandidates(
-        ownerStorage.dir,
-        resultPath
-      )) {
-        const memory = await ownerStorage.storage.readMemoryByPath(candidate);
-        if (memory) return memory;
+      try {
+        await recordEvalShadowRecall({
+          memoryDir: this.config.memoryDir,
+          evalStoreDir: this.config.evalStoreDir,
+          record: {
+            schemaVersion: 1,
+            ...record
+          }
+        });
+      } catch (err) {
+        log.debug(`eval shadow recall write failed: ${err}`);
       }
-      return null;
-    }
-    if (!fallbackStorageDir) {
-      return await fallbackStorage.readMemoryByPath(resultPath);
-    }
-    for (const candidate of qmdResultPathCandidates(
-      fallbackStorageDir,
-      resultPath
-    )) {
-      const memory = await fallbackStorage.readMemoryByPath(candidate);
-      if (memory) return memory;
+    });
+  }
+  publishRecallResults(options) {
+    const sectionId = "memories";
+    const trustByPath = options.trustByPath ?? null;
+    const injectable = trustByPath ? options.results.filter((r) => !trustByPath.get(r.path)?.quarantined) : options.results;
+    const memoryIds = this.extractMemoryIdsFromResults(injectable);
+    this.trackMemoryAccess(memoryIds);
+    this.appendRecallSection(
+      options.sectionBuckets,
+      sectionId,
+      this.formatQmdResults(options.title, injectable, options.sessionKey, trustByPath)
+    );
+  }
+  /**
+   * Apply MMR over the pre-truncation recall candidate pool and then slice
+   * the result to `limit`. This is the single place in the pipeline where
+   * MMR runs, and it must be called *before* callers throw away candidates
+   * that would otherwise sit below the final cutoff. Running MMR post-slice
+   * is a no-op in the cases we care about — diverse candidates just below
+   * the cutoff are already gone and can never be promoted.
+   *
+   * Callers must pass the full candidate pool (post-rerank, pre-slice).
+   */
+  qmdCollectionNamespaceFromPrefix(collectionPrefix) {
+    const baseCollection = this.config.qmdCollection;
+    if (collectionPrefix === baseCollection) return this.config.defaultNamespace;
+    const namespaceSuffix = collectionPrefix.startsWith(`${baseCollection}--`) ? collectionPrefix.slice(baseCollection.length + 2) : "";
+    if (!namespaceSuffix) return null;
+    const decoded = namespaceIdentityFromToken(namespaceSuffix);
+    if (decoded !== null) return decoded || this.config.defaultNamespace;
+    if (namespaceSuffix.startsWith("ns--")) {
+      const legacyNamespace = namespaceSuffix.slice("ns--".length).trim();
+      return legacyNamespace || null;
     }
     return null;
   }
+  // Issue #1526 seam 11: QMD result-resolution methods moved to QmdResultResolver.
+  // Thin delegation keeps the private API stable for callers + tests.
+  async readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces = []) {
+    return this.qmdResultResolver.readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces);
+  }
   async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
-    const memory = await this.readQmdResultMemory(
-      result.path,
-      fallbackStorage,
-      recallNamespaces
-    );
-    if (!memory) return null;
-    let ownerNamespace = null;
-    if (path5.isAbsolute(memory.path)) {
-      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        memory.path,
-        fallbackStorage,
-        recallNamespaces
-      );
-      ownerNamespace = ownerStorage?.namespace ?? null;
-      if (!ownerNamespace && resolveNamespaceCapabilities(this.config).namespaces) return null;
-    }
-    ownerNamespace ??= this.namespaceFromPath(memory.path);
-    if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
-      return null;
-    }
-    return {
-      namespace: ownerNamespace,
-      result: {
-        ...result,
-        docid: result.docid || memory.frontmatter.id,
-        path: memory.path,
-        snippet: result.snippet || memory.content.slice(0, 400)
-      }
-    };
+    return this.qmdResultResolver.resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces);
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path5.resolve(resultPath);
-    const memoryRoot = path5.resolve(this.config.memoryDir);
-    const namespacesRoot = path5.join(memoryRoot, "namespaces");
-    const fallbackStorageDir = typeof fallbackStorage.dir === "string" && fallbackStorage.dir ? fallbackStorage.dir : null;
-    const matches = [];
-    const seenDirs = /* @__PURE__ */ new Set();
-    const maybeAddStorage = (storage, namespace) => {
-      const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
-      if (!storageDir) return;
-      const candidateRoot = path5.resolve(storageDir);
-      if (seenDirs.has(candidateRoot)) return;
-      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
-      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-        return;
-      }
-      seenDirs.add(candidateRoot);
-      matches.push({ storage, dir: candidateRoot, namespace });
-    };
-    const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : this.config.defaultNamespace;
-    maybeAddStorage(fallbackStorage, fallbackNamespace);
-    const candidateNamespaces = /* @__PURE__ */ new Set();
-    candidateNamespaces.add(this.config.defaultNamespace);
-    candidateNamespaces.add(this.config.sharedNamespace);
-    for (const ns of recallNamespaces) {
-      candidateNamespaces.add(ns);
-    }
-    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path5.relative(namespacesRoot, resolvedPath);
-      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
-      if (namespaceSegment) {
-        candidateNamespaces.add(
-          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
-        );
-      }
-    }
-    for (const policy of this.config.namespacePolicies ?? []) {
-      candidateNamespaces.add(policy.name);
-    }
-    for (const ns of candidateNamespaces) {
-      if (!ns) continue;
-      try {
-        maybeAddStorage(await this.storageRouter.storageFor(ns), ns);
-      } catch {
-        continue;
-      }
-    }
-    matches.sort((a, b) => b.dir.length - a.dir.length);
-    return matches[0] ?? null;
+    return this.qmdResultResolver.storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces);
   }
   // Issue #1526: recall-rerank methods moved to RecallRerankCoordinator.
   // Thin delegation keeps the private API stable for callers + tests.
@@ -15263,30 +15571,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
@@ -15336,12 +15627,12 @@ ${reflectionsContent.trim()}
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path5.resolve(this.config.memoryDir);
-    const storageDir = path5.resolve(targetStorage.dir);
+    const memoryDir = path6.resolve(this.config.memoryDir);
+    const storageDir = path6.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path5.relative(memoryDir, storageDir);
+    let rel = path6.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`
@@ -15360,7 +15651,7 @@ ${reflectionsContent.trim()}
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path5.isAbsolute(hit.path) ? hit.path : path5.join(this.config.memoryDir, hit.path);
+      const fullPath = path6.isAbsolute(hit.path) ? hit.path : path6.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -15557,7 +15848,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 = path5.resolve(storageDir);
+          const recallRoot = path6.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -15581,8 +15872,8 @@ ${reflectionsContent.trim()}
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path5.isAbsolute(result.path)) {
-          const resolvedPath = path5.resolve(result.path);
+        if (path6.isAbsolute(result.path)) {
+          const resolvedPath = path6.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -16248,58 +16539,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
@@ -16310,40 +16554,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)
@@ -16352,42 +16568,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);
@@ -16516,4 +16701,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-VC7QELR6.js.map
+//# sourceMappingURL=chunk-VO4VARZL.js.map