@remnic/core 9.3.742 → 9.3.743

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

@@ -7,10 +7,10 @@ import {
 } from "./chunk-C7LDPZJJ.js";
 import {
   CompressionGuidelineCoordinator
-} from "./chunk-WIMKOTNY.js";
+} from "./chunk-5QANTTY2.js";
 import {
   MaintenanceScheduler
-} from "./chunk-BJPL5WAL.js";
+} from "./chunk-MXDG6SRH.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -29,10 +29,10 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UOVDO6TC.js";
+} from "./chunk-CHELXDTO.js";
 import {
   SharedContextManager
-} from "./chunk-WHEF76BQ.js";
+} from "./chunk-JRZV3767.js";
 import {
   applyTrustScoreStage,
   buildTrustSignalsForRerank,
@@ -63,7 +63,7 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-USHVHI6J.js";
+} from "./chunk-NNL4LJAD.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -160,7 +160,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-WGDE2TJP.js";
+} from "./chunk-QOGXUNWL.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -169,7 +169,7 @@ import {
 } from "./chunk-PWFWCGOO.js";
 import {
   LocalLlmClient
-} from "./chunk-TQQN64J2.js";
+} from "./chunk-DBSMLRTO.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -187,18 +187,18 @@ import {
 } from "./chunk-4463LUIE.js";
 import {
   formatDaySummaryMemories
-} from "./chunk-C3Z5YJSM.js";
+} from "./chunk-LOPZ2DWR.js";
 import {
   tryDirectAnswer
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-GPX5E36D.js";
+} from "./chunk-OSMBC3JU.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-K2N6WIZM.js";
+} from "./chunk-E7RGJQWP.js";
 import {
   RoutingRulesStore
 } from "./chunk-WIWPSQYU.js";
@@ -228,14 +228,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-O4IWVWSW.js";
+} from "./chunk-AVBT5WEW.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-X5PMDVY4.js";
+} from "./chunk-3EA5LIFJ.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-AX4TRSRE.js";
+} from "./chunk-U5WVRMCA.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -270,7 +270,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-PI4JHLDD.js";
+} from "./chunk-IP5SANO2.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -292,7 +292,7 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   SmartBuffer
-} from "./chunk-OS5RKJOH.js";
+} from "./chunk-JZ7P26GF.js";
 import {
   isDisagreementPrompt
 } from "./chunk-H3FZVNRN.js";
@@ -311,7 +311,7 @@ import {
   clusterByKey,
   createCorrectionService,
   detectPassiveCorrections
-} from "./chunk-Y6PNYJVO.js";
+} from "./chunk-A2KKLCOS.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -333,14 +333,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-OVYBENIJ.js";
+} from "./chunk-W3M34XT4.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-BE6NEQLF.js";
+} from "./chunk-HAZVVOYT.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-ELL5VYXC.js";
+} from "./chunk-RNWWAS5V.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -363,7 +363,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-Y62QPRKV.js";
+} from "./chunk-K5LLP4CY.js";
 import {
   searchCausalTrajectories
 } from "./chunk-SQNED75R.js";
@@ -465,7 +465,7 @@ import {
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-OUSOMUFV.js";
+} from "./chunk-PE6XR4GG.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule
@@ -491,7 +491,7 @@ import {
   resolveRecallEnhancementCapabilities,
   resolveSecurityCapabilities,
   resolveUtilityLearningCapabilities
-} from "./chunk-G7Q4D2G3.js";
+} from "./chunk-VSF7AAGE.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -2391,6 +2391,210 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
   }
 };
 
+// src/orchestration/recall-section-coordinator.ts
+var RecallSectionCoordinator = class {
+  getConfig;
+  resolveSectionEnabled;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.resolveSectionEnabled = options.resolveSectionEnabled ?? ((id, def) => this.isRecallSectionEnabled(id, def));
+  }
+  getRecallSectionEntry(sectionId) {
+    const pipeline = Array.isArray(this.getConfig().recallPipeline) ? this.getConfig().recallPipeline : [];
+    return pipeline.find((entry) => entry.id === sectionId);
+  }
+  isRecallSectionEnabled(sectionId, defaultEnabled = true) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return defaultEnabled;
+    return entry.enabled !== false;
+  }
+  isSpecializedRecallSectionEnabled(sectionId, topLevelEnabled) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return topLevelEnabled;
+    return entry.enabled === true || topLevelEnabled && entry.enabled !== false;
+  }
+  getRecallSectionMaxChars(sectionId) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return void 0;
+    if (entry.maxChars === null) return null;
+    if (typeof entry.maxChars !== "number") return void 0;
+    return Math.max(0, Math.floor(entry.maxChars));
+  }
+  getRecallSectionNumber(sectionId, key) {
+    const entry = this.getRecallSectionEntry(sectionId);
+    if (!entry) return void 0;
+    const value = entry[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+    return Math.max(0, Math.floor(value));
+  }
+  appendRecallSection(sectionBuckets, sectionId, content) {
+    if (!this.resolveSectionEnabled(sectionId, true)) return false;
+    const trimmed = content.trim();
+    if (trimmed.length === 0) return false;
+    const maxChars = this.getRecallSectionMaxChars(sectionId);
+    let finalContent = trimmed;
+    if (maxChars === 0) return false;
+    if (typeof maxChars === "number" && finalContent.length > maxChars) {
+      finalContent = `${finalContent.slice(0, maxChars)}
+
+...(trimmed)
+`;
+    }
+    const existing = sectionBuckets.get(sectionId) ?? [];
+    existing.push(finalContent);
+    sectionBuckets.set(sectionId, existing);
+    return true;
+  }
+  truncateRecallSectionToBudget(content, maxChars) {
+    if (maxChars <= 0) return "";
+    if (content.length <= maxChars) return content;
+    const suffix = "\n\n...(memory context trimmed)";
+    if (maxChars <= suffix.length) {
+      return content.slice(0, maxChars);
+    }
+    return `${content.slice(0, maxChars - suffix.length)}${suffix}`;
+  }
+  protectedRecallSectionIds(sectionBuckets) {
+    const protectedIds = /* @__PURE__ */ new Set();
+    if ((sectionBuckets.get("memories")?.length ?? 0) > 0) {
+      protectedIds.add("memories");
+    }
+    return protectedIds;
+  }
+  protectedRecallReservationChars(content) {
+    const headingBoundary = content.indexOf("\n\n");
+    const headingChars = headingBoundary >= 0 ? headingBoundary + 2 : Math.min(content.length, 24);
+    return Math.min(content.length, Math.max(headingChars, 24));
+  }
+  estimateReservedRecallBudget(entries, startIndex, protectedIds, alreadyIncludedCount) {
+    const separatorLength = "\n\n---\n\n".length;
+    let reserved = 0;
+    let simulatedIncluded = alreadyIncludedCount;
+    for (let i = startIndex; i < entries.length; i += 1) {
+      const entry = entries[i];
+      if (!entry || !protectedIds.has(entry.id)) continue;
+      if (simulatedIncluded > 0) {
+        reserved += separatorLength;
+      }
+      reserved += this.protectedRecallReservationChars(entry.content);
+      simulatedIncluded += 1;
+    }
+    return reserved;
+  }
+  getRecallBudgetChars(override) {
+    if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
+      return Math.floor(override);
+    }
+    const configuredBudget = this.getConfig().recallBudgetChars;
+    if (typeof configuredBudget === "number" && Number.isFinite(configuredBudget) && configuredBudget >= 0) {
+      return Math.floor(configuredBudget);
+    }
+    const tokenBudget = this.getConfig().maxMemoryTokens;
+    if (typeof tokenBudget === "number" && Number.isFinite(tokenBudget) && tokenBudget >= 0) {
+      return Math.floor(tokenBudget * 4);
+    }
+    return 0;
+  }
+  assembleRecallSections(sectionBuckets, budgetOverride) {
+    const orderedEntries = [];
+    const pipeline = Array.isArray(this.getConfig().recallPipeline) ? this.getConfig().recallPipeline : [];
+    const orderedIds = pipeline.filter((entry) => entry.enabled !== false).map((entry) => entry.id);
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of orderedIds) {
+      const chunks = sectionBuckets.get(id);
+      if (!chunks || chunks.length === 0) continue;
+      orderedEntries.push({ id, content: chunks.join("\n\n") });
+      seen.add(id);
+    }
+    for (const [id, chunks] of sectionBuckets.entries()) {
+      if (seen.has(id)) continue;
+      if (chunks.length === 0) continue;
+      orderedEntries.push({ id, content: chunks.join("\n\n") });
+    }
+    const budget = this.getRecallBudgetChars(budgetOverride);
+    if (budget === 0) {
+      return {
+        sections: [],
+        includedIds: [],
+        omittedIds: orderedEntries.map((entry) => entry.id),
+        truncated: orderedEntries.length > 0,
+        finalChars: 0
+      };
+    }
+    const separator = "\n\n---\n\n";
+    const protectedIds = this.protectedRecallSectionIds(sectionBuckets);
+    const sections = [];
+    const includedIds = [];
+    const omittedIds = [];
+    let usedChars = 0;
+    let truncated = false;
+    for (let index = 0; index < orderedEntries.length; index += 1) {
+      const entry = orderedEntries[index];
+      const separatorChars = sections.length > 0 ? separator.length : 0;
+      const reserve = protectedIds.has(entry.id) ? 0 : this.estimateReservedRecallBudget(
+        orderedEntries,
+        index + 1,
+        protectedIds,
+        sections.length + 1
+      );
+      const availableForEntry = budget - usedChars - separatorChars - reserve;
+      if (availableForEntry <= 0) {
+        omittedIds.push(entry.id);
+        truncated = true;
+        continue;
+      }
+      const finalContent = this.truncateRecallSectionToBudget(
+        entry.content,
+        availableForEntry
+      );
+      if (!finalContent) {
+        omittedIds.push(entry.id);
+        truncated = true;
+        continue;
+      }
+      if (finalContent.length < entry.content.length) {
+        truncated = true;
+      }
+      sections.push(finalContent);
+      includedIds.push(entry.id);
+      usedChars += separatorChars + finalContent.length;
+    }
+    return {
+      sections,
+      includedIds,
+      omittedIds,
+      truncated,
+      finalChars: usedChars
+    };
+  }
+  buildLastRecallBudgetSummary(options) {
+    return {
+      requestedTopK: options.requestedTopK,
+      appliedTopK: options.recallResultLimit,
+      recallBudgetChars: this.getRecallBudgetChars(),
+      maxMemoryTokens: this.getConfig().maxMemoryTokens,
+      qmdFetchLimit: options.qmdFetchLimit,
+      qmdHybridFetchLimit: options.qmdHybridFetchLimit,
+      finalContextChars: options.finalContextChars,
+      truncated: options.truncated,
+      includedSections: [...options.includedSections ?? []],
+      omittedSections: [...options.omittedSections ?? []]
+    };
+  }
+  collectLastRecallSources(sectionBuckets, recallSource) {
+    const used = /* @__PURE__ */ new Set();
+    if (recallSource !== "none") {
+      used.add(recallSource);
+    }
+    for (const [sectionId, chunks] of sectionBuckets.entries()) {
+      if (chunks.length > 0) {
+        used.add(sectionId);
+      }
+    }
+    return [...used];
+  }
+};
+
 // src/orchestration/qmd-result-resolver.ts
 import path4 from "path";
 function qmdCollectionPathParts(resultPath) {
@@ -2642,6 +2846,176 @@ var QmdResultResolver = class {
   }
 };
 
+// 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);
@@ -4767,7 +5141,9 @@ var Orchestrator = class _Orchestrator {
    */
   conversationIndexCoordinator;
   recallRerankCoordinator;
+  recallSectionCoordinator;
   qmdResultResolver;
+  contradictionLinkingCoordinator;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
@@ -5500,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);
@@ -6115,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,
@@ -7968,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
@@ -15304,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
@@ -16289,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
@@ -16351,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)
@@ -16393,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);
@@ -16557,4 +16701,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-7HUGLMSW.js.map
+//# sourceMappingURL=chunk-VO4VARZL.js.map