@remnic/core 9.3.732 → 9.3.734

package/dist/{chunk-OUITHS6V.js → chunk-Z7J3OAPR.js}

@@ -10,7 +10,10 @@ import {
 } from "./chunk-SYX73XD7.js";
 import {
   MaintenanceScheduler
-} from "./chunk-CGPHMNL4.js";
+} from "./chunk-5OYHJIJN.js";
+import {
+  runPeerProfileReasoner
+} from "./chunk-I74SUMNI.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
@@ -26,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-ZVHRSR2R.js";
+} from "./chunk-ET5HXSQL.js";
 import {
   SharedContextManager
 } from "./chunk-UFS7OXGL.js";
@@ -60,7 +63,7 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-DKT3X5C3.js";
+} from "./chunk-PEF2XOIV.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -157,7 +160,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-NIZQH6AU.js";
+} from "./chunk-WTTVFSCO.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -166,7 +169,7 @@ import {
 } from "./chunk-PWFWCGOO.js";
 import {
   LocalLlmClient
-} from "./chunk-24D66MMN.js";
+} from "./chunk-2L5RTVMO.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -190,12 +193,12 @@ import {
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-P3VJCTVE.js";
+} from "./chunk-UH3NYOHN.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-OTQE66IX.js";
+} from "./chunk-V5OVSGB6.js";
 import {
   RoutingRulesStore
 } from "./chunk-WIWPSQYU.js";
@@ -225,14 +228,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-KSJCXXOU.js";
+} from "./chunk-FAGERSH2.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-FFUCCKPN.js";
+} from "./chunk-7FPJFCXL.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-ZQUAVZNG.js";
+} from "./chunk-54RCE5Z3.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -330,14 +333,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-J6BH2OBA.js";
+} from "./chunk-UK6U5C3N.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-KQYGNGON.js";
+} from "./chunk-3QETM5NG.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-HHNSLPX7.js";
+} from "./chunk-K7PAILHO.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -360,14 +363,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-PMAQRUN4.js";
-import {
-  resolveCapabilities,
-  resolveCreationMemoryCapabilities,
-  resolveGraphConstructionCapabilities,
-  resolveIndexingCapabilities,
-  resolveMemoryLifecycleCapabilities
-} from "./chunk-ESF7TRYJ.js";
+} from "./chunk-CILX2XW7.js";
 import {
   searchCausalTrajectories
 } from "./chunk-SQNED75R.js";
@@ -469,7 +465,18 @@ import {
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-UZYLX7M6.js";
+} from "./chunk-LV32K4OP.js";
+import {
+  resolveCapabilities,
+  resolveCreationMemoryCapabilities,
+  resolveGraphConstructionCapabilities,
+  resolveIdentityContinuityCapabilities,
+  resolveIndexingCapabilities,
+  resolveLocalLlmCapabilities,
+  resolveMemoryLifecycleCapabilities,
+  resolveNamespaceCapabilities,
+  resolveQmdCapabilities
+} from "./chunk-SHJGBAIW.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule
@@ -587,7 +594,7 @@ var TierMigrationCoordinator = class {
     const { config, tierMigrationStatus } = this.deps;
     const dryRun = options?.dryRun === true;
     const persistSkipped = options?.force === true || trigger === "manual";
-    if (!config.qmdTierMigrationEnabled && options?.force !== true) {
+    if (!resolveQmdCapabilities(config).qmdTierMigration && options?.force !== true) {
       const skipped = {
         trigger,
         scanned: 0,
@@ -601,7 +608,7 @@ var TierMigrationCoordinator = class {
       if (persistSkipped) await tierMigrationStatus.recordCycle(skipped);
       return skipped;
     }
-    if (trigger === "maintenance" && !config.qmdTierAutoBackfillEnabled && options?.force !== true) {
+    if (trigger === "maintenance" && !resolveQmdCapabilities(config).qmdTierAutoBackfill && options?.force !== true) {
       const skipped = {
         trigger,
         scanned: 0,
@@ -649,7 +656,7 @@ var TierMigrationCoordinator = class {
     }
     const policy = applyUtilityPromotionRuntimePolicy(
       {
-        enabled: config.qmdTierMigrationEnabled,
+        enabled: resolveQmdCapabilities(config).qmdTierMigration,
         demotionMinAgeDays: config.qmdTierDemotionMinAgeDays,
         demotionValueThreshold: config.qmdTierDemotionValueThreshold,
         promotionValueThreshold: config.qmdTierPromotionValueThreshold
@@ -684,7 +691,7 @@ var TierMigrationCoordinator = class {
         qmd: this.deps.getQmd(),
         hotCollection: config.qmdCollection,
         coldCollection: config.qmdColdCollection ?? `${config.qmdCollection}-cold`,
-        autoEmbed: config.qmdAutoEmbedEnabled
+        autoEmbed: resolveQmdCapabilities(config).qmdAutoEmbed
       });
       let migrated = 0;
       let promoted = 0;
@@ -872,6 +879,257 @@ var ExtractionQueueCoordinator = class {
   }
 };
 
+// src/orchestration/semantic-consolidation-coordinator.ts
+var SemanticConsolidationCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  get config() {
+    return this.deps.config;
+  }
+  async runSemanticConsolidation(options) {
+    const targetStorage = options?.storage ?? this.deps.getStorage();
+    const result = {
+      clustersFound: 0,
+      memoriesConsolidated: 0,
+      memoriesArchived: 0,
+      errors: 0,
+      clusters: []
+    };
+    if (!this.config.semanticConsolidationEnabled && !options?.force) {
+      log.debug("[semantic-consolidation] disabled in config");
+      return result;
+    }
+    log.info("[semantic-consolidation] starting run");
+    const allMemories = await targetStorage.readAllMemories();
+    if (allMemories.length < 10) {
+      log.debug("[semantic-consolidation] too few memories, skipping");
+      return result;
+    }
+    const threshold = options?.thresholdOverride ?? this.config.semanticConsolidationThreshold;
+    const clusters = findSimilarClusters(allMemories, {
+      threshold,
+      minClusterSize: this.config.semanticConsolidationMinClusterSize,
+      excludeCategories: this.config.semanticConsolidationExcludeCategories,
+      maxPerRun: this.config.semanticConsolidationMaxPerRun
+    });
+    result.clustersFound = clusters.length;
+    result.clusters = clusters;
+    if (clusters.length === 0) {
+      log.info("[semantic-consolidation] no clusters found");
+      return result;
+    }
+    log.info(`[semantic-consolidation] found ${clusters.length} cluster(s)`);
+    if (options?.dryRun) {
+      log.info(
+        "[semantic-consolidation] dry run \u2014 skipping LLM synthesis and archival"
+      );
+      return result;
+    }
+    const useGateway = this.config.modelSource === "gateway";
+    const modelSetting = this.config.semanticConsolidationModel;
+    if (modelSetting === "fast" && this.deps.getFastLlm() && !useGateway) {
+      log.info("[semantic-consolidation] using fast local LLM for synthesis");
+    }
+    const gatewayChainOptions = !useGateway ? {} : modelSetting === "fast" ? this.config.fastGatewayAgentId ? { agentId: this.config.fastGatewayAgentId } : this.config.gatewayAgentId ? { agentId: this.config.gatewayAgentId } : {} : gatewayTaskChainOptions(this.config);
+    const llm = new FallbackLlmClient(
+      this.config.gatewayConfig,
+      fallbackLlmRuntimeContextFromConfig(this.config)
+    );
+    if (!llm.isAvailable(gatewayChainOptions) && !(modelSetting === "fast" && this.deps.getFastLlm() && !useGateway)) {
+      log.warn(
+        "[semantic-consolidation] no LLM available \u2014 skipping synthesis"
+      );
+      return result;
+    }
+    let extensionsBlock = "";
+    try {
+      extensionsBlock = await buildExtensionsBlockForConsolidation(this.config);
+    } catch (err) {
+      log.warn(`[semantic-consolidation] extension discovery failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    for (const cluster of clusters) {
+      let canonicalWriteCompleted = false;
+      try {
+        const operatorAwareEnabled = this.config.operatorAwareConsolidationEnabled === true;
+        let prompt = operatorAwareEnabled ? buildOperatorAwareConsolidationPrompt(cluster) : buildConsolidationPrompt(cluster);
+        if (extensionsBlock.length > 0) {
+          prompt += "\n\n" + extensionsBlock;
+        }
+        const messages = [
+          {
+            role: "system",
+            content: operatorAwareEnabled ? 'You are a memory consolidation system. Return ONLY a JSON object with two keys, "operator" and "output". The "operator" value MUST be one of the exact strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder, never prose. The "output" value is the canonical memory text.' : "You are a memory consolidation system. Output only the consolidated memory text."
+          },
+          { role: "user", content: prompt }
+        ];
+        const llmOpts = { temperature: 0.2, maxTokens: 2e3 };
+        let response = null;
+        if (useGateway) {
+          response = await llm.chatCompletion(messages, { ...llmOpts, ...gatewayChainOptions });
+        } else if (modelSetting === "fast" && this.deps.getFastLlm()) {
+          const fastResult = await this.deps.getFastLlm().chatCompletion(messages, {
+            operation: "semantic-consolidation",
+            maxTokens: llmOpts.maxTokens,
+            temperature: llmOpts.temperature,
+            priority: "background",
+            forceDisableThinking: true
+          });
+          response = fastResult ? { content: fastResult.content } : null;
+        } else {
+          response = await llm.chatCompletion(messages, llmOpts);
+        }
+        if (!response?.content) {
+          log.warn(
+            `[semantic-consolidation] empty LLM response for cluster in "${cluster.category}"`
+          );
+          result.errors++;
+          continue;
+        }
+        let canonicalContent;
+        let operator;
+        if (operatorAwareEnabled) {
+          const parsed = parseOperatorAwareConsolidationResponse(
+            response.content,
+            cluster
+          );
+          canonicalContent = parsed.output;
+          operator = parsed.operator;
+        } else {
+          canonicalContent = parseConsolidationResponse(response.content);
+          operator = chooseConsolidationOperator(cluster);
+        }
+        cluster.canonicalContent = canonicalContent;
+        const sorted = [...cluster.memories].sort(
+          (a, b) => new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime()
+        );
+        const newest = sorted[0];
+        const lineageIds = cluster.memories.map((m) => m.frontmatter.id);
+        const derivedFromEntries = [];
+        for (const m of cluster.memories) {
+          if (!m.path) continue;
+          const entry = await targetStorage.snapshotForProvenance(m.path);
+          if (entry) derivedFromEntries.push(entry);
+        }
+        const { id: canonicalId, tombstoneBlocked: canonicalBlocked } = await targetStorage.writeMemory(
+          newest.frontmatter.category,
+          canonicalContent,
+          {
+            actor: "semantic-consolidation",
+            confidence: newest.frontmatter.confidence,
+            tags: [
+              ...new Set(
+                cluster.memories.flatMap((m) => m.frontmatter.tags ?? [])
+              )
+            ],
+            source: "semantic-consolidation",
+            lineage: lineageIds,
+            derivedFrom: derivedFromEntries.length > 0 ? derivedFromEntries : void 0,
+            derivedVia: operator
+          }
+        );
+        if (canonicalBlocked) {
+          log.info(`[semantic-consolidation] cluster in "${cluster.category}" tombstone-blocked \u2014 keeping ${cluster.memories.length} source(s) active (pending_review ${canonicalId})`);
+          continue;
+        }
+        canonicalWriteCompleted = true;
+        result.memoriesConsolidated++;
+        for (const m of cluster.memories) {
+          const archiveResult = await targetStorage.archiveMemory(m, {
+            actor: "semantic-consolidation",
+            reasonCode: "semantic-consolidation",
+            relatedMemoryIds: [canonicalId]
+          });
+          if (archiveResult) {
+            await this.deps.removeContentHashForMemory(
+              targetStorage,
+              m,
+              "semantic-consolidation"
+            );
+            try {
+              await this.deps.embeddingFallback.removeFromIndex(m.frontmatter.id);
+              if (resolveIndexingCapabilities(this.config).queryAwareIndexing && m.path && m.frontmatter?.created) {
+                deindexMemory(
+                  targetStorage.dir,
+                  m.path,
+                  m.frontmatter.created,
+                  m.frontmatter.tags ?? []
+                );
+              }
+            } catch (cleanupErr) {
+              log.warn(
+                `[semantic-consolidation] index cleanup failed (non-fatal): ${cleanupErr}`
+              );
+            }
+            result.memoriesArchived++;
+          }
+        }
+        log.info(
+          `[semantic-consolidation] consolidated ${cluster.memories.length} memories \u2192 ${canonicalId}`
+        );
+      } catch (err) {
+        log.warn(
+          `[semantic-consolidation] cluster processing failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        result.errors++;
+      } finally {
+        if (canonicalWriteCompleted) {
+        }
+      }
+    }
+    if (result.memoriesArchived > 0) {
+      await this.deps.saveContentHashIndexes().catch(
+        (err) => log.warn(
+          `[semantic-consolidation] content-hash index save failed: ${err}`
+        )
+      );
+    }
+    log.info(
+      `[semantic-consolidation] complete: clusters=${result.clustersFound}, consolidated=${result.memoriesConsolidated}, archived=${result.memoriesArchived}, errors=${result.errors}`
+    );
+    try {
+      await materializeAfterSemanticConsolidation({
+        config: this.config,
+        memoryDir: targetStorage.dir
+      });
+    } catch (err) {
+      log.warn(
+        `[semantic-consolidation] Codex materialize post-hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (this.config.peerProfileReasonerEnabled) {
+      try {
+        const peerLlm = new FallbackLlmClient(
+          this.config.gatewayConfig,
+          fallbackLlmRuntimeContextFromConfig(this.config)
+        );
+        const peerResult = await runPeerProfileReasoner({
+          memoryDir: targetStorage.dir,
+          enabled: true,
+          llm: peerLlm,
+          model: this.config.peerProfileReasonerModel,
+          minInteractions: this.config.peerProfileReasonerMinInteractions,
+          maxFieldsPerRun: this.config.peerProfileReasonerMaxFieldsPerRun,
+          log: {
+            debug: (msg) => log.debug(msg),
+            info: (msg) => log.info(msg),
+            warn: (msg) => log.warn(msg)
+          }
+        });
+        log.info(
+          `[peer-profile-reasoner] complete: peers=${peerResult.peersConsidered}, processed=${peerResult.peersProcessed}, fields=${peerResult.fieldsApplied}`
+        );
+      } catch (err) {
+        log.warn(
+          `[peer-profile-reasoner] post-consolidation hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return result;
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -3031,6 +3289,7 @@ var Orchestrator = class _Orchestrator {
   tierMigrationStatus;
   tierMigrationCoordinator;
   compressionGuidelineCoordinator;
+  semanticConsolidationCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -3324,7 +3583,7 @@ var Orchestrator = class _Orchestrator {
    * @internal
    */
   applyCodingNamespaceOverlay(sessionKey, baseNamespace) {
-    if (!this.config.namespacesEnabled) return baseNamespace;
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return baseNamespace;
     const codingContext = this.getCodingContextForSession(sessionKey);
     const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode, this.config.defaultNamespace);
     if (!overlay) return baseNamespace;
@@ -3392,7 +3651,7 @@ var Orchestrator = class _Orchestrator {
    * @internal
    */
   applyCodingRecallOverlay(sessionKey) {
-    if (!this.config.namespacesEnabled) return null;
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return null;
     const codingContext = this.getCodingContextForSession(sessionKey);
     const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode, this.config.defaultNamespace);
     if (!overlay) return null;
@@ -3406,7 +3665,7 @@ var Orchestrator = class _Orchestrator {
     return getConfiguredNamespaces(this.config);
   }
   rememberNamespaceStorageDirHint(namespace, storageDir) {
-    if (!this.config.namespacesEnabled || !storageDir) return;
+    if (!resolveNamespaceCapabilities(this.config).namespaces || !storageDir) return;
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return;
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
@@ -3557,8 +3816,8 @@ var Orchestrator = class _Orchestrator {
     return summarizeNamespaceMaintenanceHealth(this.config);
   }
   buildConfiguredQmdSearchOptions(queryText) {
-    const intentHint = this.config.qmdIntentHintsEnabled ? buildQmdIntentHint(inferIntentFromText(queryText)) : void 0;
-    const explain = this.config.qmdExplainEnabled === true;
+    const intentHint = resolveQmdCapabilities(this.config).qmdIntentHints ? buildQmdIntentHint(inferIntentFromText(queryText)) : void 0;
+    const explain = resolveQmdCapabilities(this.config).qmdExplain === true;
     const searchOptions = {};
     if (intentHint) {
       searchOptions.intent = intentHint;
@@ -3569,15 +3828,15 @@ var Orchestrator = class _Orchestrator {
     return Object.keys(searchOptions).length > 0 ? searchOptions : void 0;
   }
   async searchAcrossNamespaces(options) {
-    if (this.config.namespacesEnabled && options.namespaces !== void 0 && options.namespaces.length === 0) {
+    if (resolveNamespaceCapabilities(this.config).namespaces && options.namespaces !== void 0 && options.namespaces.length === 0) {
       return [];
     }
-    const namespaces = this.config.namespacesEnabled ? Array.from(
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? Array.from(
       new Set(
         (options.namespaces?.length ? options.namespaces : this.configuredNamespaceList()).map((value) => value.trim()).filter(Boolean)
       )
     ) : [this.config.defaultNamespace];
-    if (!this.config.namespacesEnabled) {
+    if (!resolveNamespaceCapabilities(this.config).namespaces) {
       switch (options.mode) {
         case "hybrid":
           return await this.qmd.hybridSearch(
@@ -3623,7 +3882,7 @@ var Orchestrator = class _Orchestrator {
     return await this.namespaceSearchRouter.healthForNamespace(namespace, execution);
   }
   isSearchAvailableForNamespaceRouting() {
-    if (this.config.namespacesEnabled) return true;
+    if (resolveNamespaceCapabilities(this.config).namespaces) return true;
     return this.qmd.isAvailable();
   }
   invalidateLiveContentHashIndex() {
@@ -3891,6 +4150,14 @@ var Orchestrator = class _Orchestrator {
       client.disableThinking = true;
       return client;
     })() : this.localLlm;
+    this.semanticConsolidationCoordinator = new SemanticConsolidationCoordinator({
+      config,
+      getStorage: () => this.storage,
+      getFastLlm: () => this.fastLlm,
+      embeddingFallback: this.embeddingFallback,
+      removeContentHashForMemory: (targetStorage, memory, context) => this.removeContentHashForMemory(targetStorage, memory, context),
+      saveContentHashIndexes: () => this.saveContentHashIndexes()
+    });
     this._fastGatewayLlm = config.modelSource === "gateway" ? new FallbackLlmClient(
       config.gatewayConfig,
       fallbackLlmRuntimeContextFromConfig(config)
@@ -4003,7 +4270,7 @@ var Orchestrator = class _Orchestrator {
     };
   }
   routeEngineOptions() {
-    const allowedNamespaces = this.config.namespacesEnabled ? Array.from(
+    const allowedNamespaces = resolveNamespaceCapabilities(this.config).namespaces ? Array.from(
       /* @__PURE__ */ new Set([
         this.config.defaultNamespace,
         this.config.sharedNamespace,
@@ -4143,7 +4410,7 @@ var Orchestrator = class _Orchestrator {
   get briefingChainFollowupGenerator() {
     const chainAvailable = this.config.modelSource === "gateway" ? this._fastGatewayLlm?.isAvailable(
       this.config.fastGatewayAgentId || this.config.gatewayAgentId || void 0
-    ) === true : this.config.localLlmEnabled;
+    ) === true : resolveLocalLlmCapabilities(this.config).localLlm;
     if (!chainAvailable) return void 0;
     return buildChainFollowupGenerator(this.fastLlmForRerank);
   }
@@ -4158,7 +4425,7 @@ var Orchestrator = class _Orchestrator {
       });
       await this.storage.ensureDirectories();
       await this.storage.loadAliases();
-      if (this.config.namespacesEnabled) {
+      if (resolveNamespaceCapabilities(this.config).namespaces) {
         const namespaces = /* @__PURE__ */ new Set([
           this.config.defaultNamespace,
           this.config.sharedNamespace,
@@ -4247,12 +4514,12 @@ var Orchestrator = class _Orchestrator {
         const available = await this.qmd.probe();
         if (available) {
           log.info(`Search backend: available ${this.qmd.debugStatus()}`);
-          const namespaces = this.config.namespacesEnabled ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
+          const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
           const states = await Promise.all(
             namespaces.map(async (namespace) => {
               const collectionCheckAbort = new AbortController();
               const state = await qmdStartupCollectionCheckWithTimeout(
-                this.config.namespacesEnabled ? this.namespaceSearchRouter.ensureNamespaceCollection(
+                resolveNamespaceCapabilities(this.config).namespaces ? this.namespaceSearchRouter.ensureNamespaceCollection(
                   namespace,
                   { signal: collectionCheckAbort.signal }
                 ) : this.qmd.ensureCollection(
@@ -4327,10 +4594,10 @@ var Orchestrator = class _Orchestrator {
   }
   async deferredInitialize(signal) {
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    if (this.qmd.isAvailable() && this.config.qmdMaintenanceEnabled) {
+    if (this.qmd.isAvailable() && resolveQmdCapabilities(this.config).qmdMaintenance) {
       try {
         log.info("QMD startup sync: updating index to match current disk state");
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           await this.namespaceSearchRouter.updateNamespaces(
             await this.maintenanceNamespaces(),
             { signal }
@@ -4414,7 +4681,7 @@ var Orchestrator = class _Orchestrator {
       }
     }
     if (signal.aborted) return;
-    if (this.config.localLlmEnabled) {
+    if (resolveLocalLlmCapabilities(this.config).localLlm) {
       try {
         await this.validateLocalLlmModel();
       } catch (err) {
@@ -4424,9 +4691,9 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     await this.maintenanceScheduler.autoRegisterCrons(signal);
     if (signal.aborted) return;
-    if (lifecycleCaps.lifecyclePolicy && this.config.qmdTierMigrationEnabled) {
+    if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-OOR57AYR.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-W4U6XDKI.js");
         const result = await runFirstStartMigration({
           storage: this.storage,
           config: this.config,
@@ -4500,14 +4767,14 @@ var Orchestrator = class _Orchestrator {
       return false;
     }
     log.info(`startupSearchSync: backend now available ${this.qmd.debugStatus()}`);
-    if (this.config.namespacesEnabled) {
+    if (resolveNamespaceCapabilities(this.config).namespaces) {
       this.namespaceSearchRouter.clearCache();
     }
-    const namespaces = this.config.namespacesEnabled ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
     const states = await Promise.all(
       namespaces.map(async (namespace) => ({
         namespace,
-        state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace, { signal }) : await this.qmd.ensureCollection(this.config.memoryDir, this.config.qmdCollection, { signal })
+        state: resolveNamespaceCapabilities(this.config).namespaces ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace, { signal }) : await this.qmd.ensureCollection(this.config.memoryDir, this.config.qmdCollection, { signal })
       }))
     );
     if (signal?.aborted) {
@@ -4524,7 +4791,7 @@ var Orchestrator = class _Orchestrator {
       log.warn("startupSearchSync: search collection missing; disabling search (fallback retrieval remains enabled)");
       return false;
     }
-    if (this.config.qmdMaintenanceEnabled) {
+    if (resolveQmdCapabilities(this.config).qmdMaintenance) {
       try {
         const failTsBefore = "lastUpdateFailedAtMs" in this.qmd ? this.qmd.lastUpdateFailedAtMs : null;
         const hasRunTs = "lastUpdateRanAtMs" in this.qmd;
@@ -4533,7 +4800,7 @@ var Orchestrator = class _Orchestrator {
         }
         log.info("startupSearchSync: updating index to match current disk state");
         let namespacesUpdated = 0;
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           namespacesUpdated = await this.namespaceSearchRouter.updateNamespaces(
             namespaces,
             { signal }
@@ -4551,7 +4818,7 @@ var Orchestrator = class _Orchestrator {
           log.warn("startupSearchSync: update silently failed (detected via fail timestamp)");
           return false;
         }
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           if (namespacesUpdated === 0) {
             log.warn("startupSearchSync: no namespace backends were eligible for update (all unavailable or collections missing)");
             return false;
@@ -4831,247 +5098,12 @@ ${doc.content}` : doc.content,
     }
     return summarizeGovernanceResultForDreams(govResult, options?.dryRun === true);
   }
+  // Issue #1526 (seam 5): semantic consolidation moved to
+  // SemanticConsolidationCoordinator. Thin delegation keeps all
+  // call sites (runConsolidation, runSemanticConsolidationNow,
+  // runSemanticConsolidationFanout) stable.
   async runSemanticConsolidation(options) {
-    const targetStorage = options?.storage ?? this.storage;
-    const result = {
-      clustersFound: 0,
-      memoriesConsolidated: 0,
-      memoriesArchived: 0,
-      errors: 0,
-      clusters: []
-    };
-    if (!this.config.semanticConsolidationEnabled && !options?.force) {
-      log.debug("[semantic-consolidation] disabled in config");
-      return result;
-    }
-    log.info("[semantic-consolidation] starting run");
-    const allMemories = await targetStorage.readAllMemories();
-    if (allMemories.length < 10) {
-      log.debug("[semantic-consolidation] too few memories, skipping");
-      return result;
-    }
-    const threshold = options?.thresholdOverride ?? this.config.semanticConsolidationThreshold;
-    const clusters = findSimilarClusters(allMemories, {
-      threshold,
-      minClusterSize: this.config.semanticConsolidationMinClusterSize,
-      excludeCategories: this.config.semanticConsolidationExcludeCategories,
-      maxPerRun: this.config.semanticConsolidationMaxPerRun
-    });
-    result.clustersFound = clusters.length;
-    result.clusters = clusters;
-    if (clusters.length === 0) {
-      log.info("[semantic-consolidation] no clusters found");
-      return result;
-    }
-    log.info(`[semantic-consolidation] found ${clusters.length} cluster(s)`);
-    if (options?.dryRun) {
-      log.info(
-        "[semantic-consolidation] dry run \u2014 skipping LLM synthesis and archival"
-      );
-      return result;
-    }
-    const { FallbackLlmClient: FallbackLlmClient2, gatewayTaskChainOptions: gatewayTaskChainOptions2 } = await import("./fallback-llm.js");
-    const useGateway = this.config.modelSource === "gateway";
-    const modelSetting = this.config.semanticConsolidationModel;
-    if (modelSetting === "fast" && this.fastLlm && !useGateway) {
-      log.info("[semantic-consolidation] using fast local LLM for synthesis");
-    }
-    const gatewayChainOptions = !useGateway ? {} : modelSetting === "fast" ? this.config.fastGatewayAgentId ? { agentId: this.config.fastGatewayAgentId } : this.config.gatewayAgentId ? { agentId: this.config.gatewayAgentId } : {} : gatewayTaskChainOptions2(this.config);
-    const llm = new FallbackLlmClient2(
-      this.config.gatewayConfig,
-      fallbackLlmRuntimeContextFromConfig(this.config)
-    );
-    if (!llm.isAvailable(gatewayChainOptions) && !(modelSetting === "fast" && this.fastLlm && !useGateway)) {
-      log.warn(
-        "[semantic-consolidation] no LLM available \u2014 skipping synthesis"
-      );
-      return result;
-    }
-    let extensionsBlock = "";
-    try {
-      extensionsBlock = await buildExtensionsBlockForConsolidation(this.config);
-    } catch (err) {
-      log.warn(`[semantic-consolidation] extension discovery failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-    }
-    for (const cluster of clusters) {
-      let canonicalWriteCompleted = false;
-      try {
-        const operatorAwareEnabled = this.config.operatorAwareConsolidationEnabled === true;
-        let prompt = operatorAwareEnabled ? buildOperatorAwareConsolidationPrompt(cluster) : buildConsolidationPrompt(cluster);
-        if (extensionsBlock.length > 0) {
-          prompt += "\n\n" + extensionsBlock;
-        }
-        const messages = [
-          {
-            role: "system",
-            content: operatorAwareEnabled ? 'You are a memory consolidation system. Return ONLY a JSON object with two keys, "operator" and "output". The "operator" value MUST be one of the exact strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder, never prose. The "output" value is the canonical memory text.' : "You are a memory consolidation system. Output only the consolidated memory text."
-          },
-          { role: "user", content: prompt }
-        ];
-        const llmOpts = { temperature: 0.2, maxTokens: 2e3 };
-        let response = null;
-        if (useGateway) {
-          response = await llm.chatCompletion(messages, { ...llmOpts, ...gatewayChainOptions });
-        } else if (modelSetting === "fast" && this.fastLlm) {
-          const fastResult = await this.fastLlm.chatCompletion(messages, {
-            operation: "semantic-consolidation",
-            maxTokens: llmOpts.maxTokens,
-            temperature: llmOpts.temperature,
-            priority: "background",
-            forceDisableThinking: true
-          });
-          response = fastResult ? { content: fastResult.content } : null;
-        } else {
-          response = await llm.chatCompletion(messages, llmOpts);
-        }
-        if (!response?.content) {
-          log.warn(
-            `[semantic-consolidation] empty LLM response for cluster in "${cluster.category}"`
-          );
-          result.errors++;
-          continue;
-        }
-        let canonicalContent;
-        let operator;
-        if (operatorAwareEnabled) {
-          const parsed = parseOperatorAwareConsolidationResponse(
-            response.content,
-            cluster
-          );
-          canonicalContent = parsed.output;
-          operator = parsed.operator;
-        } else {
-          canonicalContent = parseConsolidationResponse(response.content);
-          operator = chooseConsolidationOperator(cluster);
-        }
-        cluster.canonicalContent = canonicalContent;
-        const sorted = [...cluster.memories].sort(
-          (a, b) => new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime()
-        );
-        const newest = sorted[0];
-        const lineageIds = cluster.memories.map((m) => m.frontmatter.id);
-        const derivedFromEntries = [];
-        for (const m of cluster.memories) {
-          if (!m.path) continue;
-          const entry = await targetStorage.snapshotForProvenance(m.path);
-          if (entry) derivedFromEntries.push(entry);
-        }
-        const { id: canonicalId, tombstoneBlocked: canonicalBlocked } = await targetStorage.writeMemory(
-          newest.frontmatter.category,
-          canonicalContent,
-          {
-            actor: "semantic-consolidation",
-            confidence: newest.frontmatter.confidence,
-            tags: [
-              ...new Set(
-                cluster.memories.flatMap((m) => m.frontmatter.tags ?? [])
-              )
-            ],
-            source: "semantic-consolidation",
-            lineage: lineageIds,
-            derivedFrom: derivedFromEntries.length > 0 ? derivedFromEntries : void 0,
-            derivedVia: operator
-          }
-        );
-        if (canonicalBlocked) {
-          log.info(`[semantic-consolidation] cluster in "${cluster.category}" tombstone-blocked \u2014 keeping ${cluster.memories.length} source(s) active (pending_review ${canonicalId})`);
-          continue;
-        }
-        canonicalWriteCompleted = true;
-        result.memoriesConsolidated++;
-        for (const m of cluster.memories) {
-          const archiveResult = await targetStorage.archiveMemory(m, {
-            actor: "semantic-consolidation",
-            reasonCode: "semantic-consolidation",
-            relatedMemoryIds: [canonicalId]
-          });
-          if (archiveResult) {
-            await this.removeContentHashForMemory(
-              targetStorage,
-              m,
-              "semantic-consolidation"
-            );
-            try {
-              await this.embeddingFallback.removeFromIndex(m.frontmatter.id);
-              if (resolveIndexingCapabilities(this.config).queryAwareIndexing && m.path && m.frontmatter?.created) {
-                deindexMemory(
-                  targetStorage.dir,
-                  m.path,
-                  m.frontmatter.created,
-                  m.frontmatter.tags ?? []
-                );
-              }
-            } catch (cleanupErr) {
-              log.warn(
-                `[semantic-consolidation] index cleanup failed (non-fatal): ${cleanupErr}`
-              );
-            }
-            result.memoriesArchived++;
-          }
-        }
-        log.info(
-          `[semantic-consolidation] consolidated ${cluster.memories.length} memories \u2192 ${canonicalId}`
-        );
-      } catch (err) {
-        log.warn(
-          `[semantic-consolidation] cluster processing failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-        result.errors++;
-      } finally {
-        if (canonicalWriteCompleted) {
-        }
-      }
-    }
-    if (result.memoriesArchived > 0) {
-      await this.saveContentHashIndexes().catch(
-        (err) => log.warn(
-          `[semantic-consolidation] content-hash index save failed: ${err}`
-        )
-      );
-    }
-    log.info(
-      `[semantic-consolidation] complete: clusters=${result.clustersFound}, consolidated=${result.memoriesConsolidated}, archived=${result.memoriesArchived}, errors=${result.errors}`
-    );
-    try {
-      await materializeAfterSemanticConsolidation({
-        config: this.config,
-        memoryDir: targetStorage.dir
-      });
-    } catch (err) {
-      log.warn(
-        `[semantic-consolidation] Codex materialize post-hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (this.config.peerProfileReasonerEnabled) {
-      try {
-        const { runPeerProfileReasoner } = await import("./peers/index.js");
-        const llm2 = new FallbackLlmClient2(
-          this.config.gatewayConfig,
-          fallbackLlmRuntimeContextFromConfig(this.config)
-        );
-        const peerResult = await runPeerProfileReasoner({
-          memoryDir: targetStorage.dir,
-          enabled: true,
-          llm: llm2,
-          model: this.config.peerProfileReasonerModel,
-          minInteractions: this.config.peerProfileReasonerMinInteractions,
-          maxFieldsPerRun: this.config.peerProfileReasonerMaxFieldsPerRun,
-          log: {
-            debug: (msg) => log.debug(msg),
-            info: (msg) => log.info(msg),
-            warn: (msg) => log.warn(msg)
-          }
-        });
-        log.info(
-          `[peer-profile-reasoner] complete: peers=${peerResult.peersConsidered}, processed=${peerResult.peersProcessed}, fields=${peerResult.fieldsApplied}`
-        );
-      } catch (err) {
-        log.warn(
-          `[peer-profile-reasoner] post-consolidation hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    return result;
+    return this.semanticConsolidationCoordinator.runSemanticConsolidation(options);
   }
   async waitForExtractionIdle(timeoutMs = 6e4) {
     return this.extractionQueueCoordinator.waitForIdle(timeoutMs);
@@ -5872,7 +5904,7 @@ ${r.snippet.trim()}
       options.abortSignal?.addEventListener("abort", onAbort, { once: true });
     }
     const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-    const namespacesEnabled = this.config.namespacesEnabled;
+    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
     if (namespacesEnabled && !principal) {
       throw new Error("authentication required: namespaces are enabled and no principal was supplied");
     }
@@ -6213,7 +6245,7 @@ ${r.snippet.trim()}
     const scoped = /* @__PURE__ */ new Set();
     for (const memoryPath of paths) {
       if (!memoryPath || isArtifactMemoryPath(memoryPath)) continue;
-      if (this.config.namespacesEnabled && !recallNamespaces.includes(this.namespaceFromPath(memoryPath))) {
+      if (resolveNamespaceCapabilities(this.config).namespaces && !recallNamespaces.includes(this.namespaceFromPath(memoryPath))) {
         continue;
       }
       scoped.add(memoryPath);
@@ -6296,7 +6328,7 @@ ${r.snippet.trim()}
     const tokens = Array.from(new Set(tokenizeRecallQuery(query)));
     const memories = (await Promise.all(
       Array.from(candidatePaths).map(async (memoryPath) => {
-        const namespace = this.config.namespacesEnabled ? this.namespaceFromPath(memoryPath) : this.config.defaultNamespace;
+        const namespace = resolveNamespaceCapabilities(this.config).namespaces ? this.namespaceFromPath(memoryPath) : this.config.defaultNamespace;
         const storage = await this.storageRouter.storageFor(namespace);
         return await storage.readMemoryByPath(memoryPath);
       })
@@ -6768,7 +6800,7 @@ ${r.snippet.trim()}
     }
   }
   async resolveStateDirForNamespace(namespace) {
-    if (!this.config.namespacesEnabled) {
+    if (!resolveNamespaceCapabilities(this.config).namespaces) {
       return path3.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
@@ -6984,7 +7016,7 @@ ${r.snippet.trim()}
     }
     const timings = {};
     const profileTraceId = this.profiler.startTrace("recall", sessionKey, {
-      qmdEnabled: this.config.qmdEnabled,
+      qmdEnabled: resolveQmdCapabilities(this.config).qmd,
       rerankEnabled: caps.rerank,
       parallelRetrieval: caps.parallelRetrieval
     });
@@ -7141,7 +7173,7 @@ ${r.snippet.trim()}
       );
       const embeddingFetchLimit = computedFetchLimit;
       const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-      const namespacesEnabled = this.config.namespacesEnabled;
+      const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
       if (namespacesEnabled && !principal) {
         throw new Error("authentication required: namespaces are enabled and no principal was supplied");
       }
@@ -7317,7 +7349,7 @@ ${r.snippet.trim()}
           retrievalQueryLength: retrievalQuery.length,
           recallMode,
           recallResultLimit,
-          qmdEnabled: this.config.qmdEnabled,
+          qmdEnabled: resolveQmdCapabilities(this.config).qmd,
           qmdAvailable: this.qmd.isAvailable(),
           recallNamespaces: [],
           source: recallSource,
@@ -7622,7 +7654,7 @@ ${lines.join("\n\n")}`;
       const identityContinuityPromise = (async () => {
         if (!this.isRecallSectionEnabled(
           "identity-continuity",
-          this.config.identityContinuityEnabled === true
+          resolveIdentityContinuityCapabilities(this.config).identityContinuity === true
         ))
           return null;
         const t0 = Date.now();
@@ -7850,13 +7882,13 @@ ${rows.join("\n")}
         }
         const objectiveStateSearches = await Promise.all(
           recallNamespaces.map(async (namespace) => {
-            const storage = this.config.namespacesEnabled ? await this.getStorage(namespace) : null;
+            const storage = resolveNamespaceCapabilities(this.config).namespaces ? await this.getStorage(namespace) : null;
             return searchObjectiveStateSnapshots({
-              memoryDir: this.config.namespacesEnabled ? storage.dir : this.config.memoryDir,
+              memoryDir: resolveNamespaceCapabilities(this.config).namespaces ? storage.dir : this.config.memoryDir,
               objectiveStateStoreDir: objectiveStateStoreOverrideForNamespace({
                 memoryDir: this.config.memoryDir,
                 configuredStoreDir: this.config.objectiveStateStoreDir,
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 namespace
               }),
               query: retrievalQuery,
@@ -8612,7 +8644,7 @@ ${rows.join("\n")}
               qmdFetchLimit,
               qmdHybridFetchLimit,
               {
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 recallNamespaces,
                 resolveNamespace: (p) => this.namespaceFromPath(p),
                 queryAwarePrefilter,
@@ -8945,7 +8977,7 @@ ${formatted}`;
             workspaceDir: this.config.workspaceDir,
             memoryDir: this.config.memoryDir,
             config: this.config.nativeKnowledge,
-            recallNamespaces: this.config.namespacesEnabled ? recallNamespaces : void 0,
+            recallNamespaces: resolveNamespaceCapabilities(this.config).namespaces ? recallNamespaces : void 0,
             defaultNamespace: this.config.defaultNamespace,
             abortSignal: nativeKnowledgeAbort.signal
           }).catch(() => []);
@@ -9700,7 +9732,7 @@ ${tmtNode.summary}`
           []
         );
         let memoryResults = memoryResultsRaw;
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           memoryResults = memoryResults.filter(
             (r) => recallNamespaces.includes(this.namespaceFromPath(r.path))
           );
@@ -9983,7 +10015,7 @@ ${tmtNode.summary}`
                 const scopedCandidates = filterRecallCandidates(
                   prefilteredEmbeddingResults,
                   {
-                    namespacesEnabled: this.config.namespacesEnabled,
+                    namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                     recallNamespaces,
                     resolveNamespace: (p) => this.namespaceFromPath(p),
                     limit: embeddingFetchLimit
@@ -10144,7 +10176,7 @@ ${tmtNode.summary}`
               const scopedCandidates = filterRecallCandidates(
                 prefilteredEmbeddingResults,
                 {
-                  namespacesEnabled: this.config.namespacesEnabled,
+                  namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                   recallNamespaces,
                   resolveNamespace: (p) => this.namespaceFromPath(p),
                   limit: embeddingFetchLimit
@@ -10809,7 +10841,7 @@ _Context: ${topQuestion.context}_`
         retrievalQueryLength: retrievalQuery.length,
         recallMode,
         recallResultLimit,
-        qmdEnabled: this.config.qmdEnabled,
+        qmdEnabled: resolveQmdCapabilities(this.config).qmd,
         qmdAvailable: this.qmd.isAvailable(),
         recallNamespaces,
         source: recallSource,
@@ -11982,7 +12014,7 @@ ${normalized}`).digest("hex");
     const profileAllowsSharedWrites = !scopeProfileWritePlan || Boolean(
       scopeProfileWritePlan.profile.readOrder.includes("serverShared") && scopeProfileWritePlan.readNamespaces.includes(this.config.sharedNamespace) && sharedProfileLayer?.readable && sharedProfileLayer.writable && sharedPromotionTarget?.authorized
     );
-    const namespacesEnabled = this.config.namespacesEnabled;
+    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
     const profileAutoPromotionAllows = (category, confidence) => {
       if (!scopeProfileWritePlan) return false;
       const actualTier = confidenceTier(confidence);
@@ -12010,7 +12042,7 @@ ${normalized}`).digest("hex");
       return scopeProfileWritePlan.profile.autoPromote.targets.includes("serverShared") && profileAutoPromotionAllows(category, confidence);
     };
     const shouldPromoteToShared = (targetStorage, category, confidence) => {
-      if (!this.config.namespacesEnabled || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(category, confidence))
+      if (!resolveNamespaceCapabilities(this.config).namespaces || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(category, confidence))
         return false;
       if (this.storageDirNamespace(targetStorage.dir) === this.config.sharedNamespace)
         return false;
@@ -13485,7 +13517,7 @@ ${normalized}`).digest("hex");
     const needsFullRebuild = !indexesExist(this.config.memoryDir);
     if (!needsFullRebuild && persistedIds.length === 0) return;
     try {
-      const allMemories = needsFullRebuild && this.config.namespacesEnabled ? await this.readAllMemoriesForNamespaces(
+      const allMemories = needsFullRebuild && resolveNamespaceCapabilities(this.config).namespaces ? await this.readAllMemoriesForNamespaces(
         Array.from(
           /* @__PURE__ */ new Set([
             this.config.defaultNamespace,
@@ -14214,10 +14246,10 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
   /** Threshold (bytes) at which IDENTITY.md reflections get auto-consolidated */
   static IDENTITY_CONSOLIDATE_THRESHOLD = 8e3;
   async autoConsolidateIdentity() {
-    const namespaces = this.config.namespacesEnabled ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
     for (const namespace of namespaces) {
       const storage = await this.storageRouter.storageFor(namespace);
-      const identityNamespace = this.config.namespacesEnabled && namespace !== this.config.defaultNamespace ? namespace : void 0;
+      const identityNamespace = resolveNamespaceCapabilities(this.config).namespaces && namespace !== this.config.defaultNamespace ? namespace : void 0;
       const reflectionsContent = await storage.readIdentityReflections() ?? "";
       const existingIdentity = await storage.readIdentity(
         this.config.workspaceDir,
@@ -14486,7 +14518,7 @@ ${lines.join("\n\n")}`;
     return { text: `${content.slice(0, headroom)}${suffix}`, truncated: true };
   }
   async buildIdentityContinuitySection(options) {
-    if (!this.config.identityContinuityEnabled) return null;
+    if (!resolveIdentityContinuityCapabilities(this.config).identityContinuity) return null;
     if (this.config.identityMaxInjectChars <= 0) return null;
     const resolved = resolveEffectiveIdentityInjectionMode({
       configuredMode: this.config.identityInjectionMode,
@@ -14625,7 +14657,7 @@ ${lines.join("\n\n")}`;
         storages.push(storage);
       };
       const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : this.config.defaultNamespace;
-      if (recallNamespaces.length === 0 || !this.config.namespacesEnabled || recallNamespaces.includes(fallbackNamespace)) {
+      if (recallNamespaces.length === 0 || !resolveNamespaceCapabilities(this.config).namespaces || recallNamespaces.includes(fallbackNamespace)) {
         addStorage(fallbackStorage);
       }
       if (recallNamespaces.length > 0) {
@@ -14736,7 +14768,7 @@ ${lines.join("\n\n")}`;
         recallNamespaces
       );
       ownerNamespace = ownerStorage?.namespace ?? null;
-      if (!ownerNamespace && this.config.namespacesEnabled) return null;
+      if (!ownerNamespace && resolveNamespaceCapabilities(this.config).namespaces) return null;
     }
     ownerNamespace ??= this.namespaceFromPath(memory.path);
     if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
@@ -15088,7 +15120,7 @@ ${lines.join("\n\n")}`;
    *     so facts from non-default namespaces can't cross-match.
    */
   semanticDedupScopeFor(targetStorage) {
-    if (!this.config.namespacesEnabled) return {};
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
     const memoryDir = path3.resolve(this.config.memoryDir);
     const storageDir = path3.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
@@ -15221,7 +15253,7 @@ ${lines.join("\n\n")}`;
         if (timeoutHandle) clearTimeout(timeoutHandle);
       }
     };
-    const coldQmdEnabled = this.config.qmdColdTierEnabled === true;
+    const coldQmdEnabled = resolveQmdCapabilities(this.config).qmdColdTier === true;
     const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
     const coldMaxResults = this.config.qmdColdMaxResults ?? this.config.qmdMaxResults;
     let longTerm = [];
@@ -15256,7 +15288,7 @@ ${lines.join("\n\n")}`;
             coldFetchLimit,
             coldHybridLimit,
             {
-              namespacesEnabled: this.config.namespacesEnabled,
+              namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
               recallNamespaces: options.recallNamespaces,
               resolveNamespace: (p) => this.namespaceFromPath(p),
               collection: coldCollection,
@@ -15302,7 +15334,7 @@ ${lines.join("\n\n")}`;
     }
     if (longTerm.length === 0) return [];
     let results = longTerm;
-    if (this.config.namespacesEnabled) {
+    if (resolveNamespaceCapabilities(this.config).namespaces) {
       const recallRoots = [];
       const seenRecallRoots = /* @__PURE__ */ new Set();
       for (const namespace of options.recallNamespaces) {
@@ -15351,8 +15383,8 @@ ${lines.join("\n\n")}`;
     }
     results = results.filter((r) => !isArtifactMemoryPath(r.path));
     if (results.length === 0) return [];
-    const isFullModeGraphAssist = this.config.qmdTierParityGraphEnabled && graphCaps.multiGraphMemory && caps.graphAssistInFullMode && options.recallMode === "full" && results.length >= Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
-    const shouldRunGraphExpansion = this.config.qmdTierParityGraphEnabled && (options.recallMode === "graph_mode" || isFullModeGraphAssist);
+    const isFullModeGraphAssist = resolveQmdCapabilities(this.config).qmdTierParityGraph && graphCaps.multiGraphMemory && caps.graphAssistInFullMode && options.recallMode === "full" && results.length >= Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
+    const shouldRunGraphExpansion = resolveQmdCapabilities(this.config).qmdTierParityGraph && (options.recallMode === "graph_mode" || isFullModeGraphAssist);
     if (shouldRunGraphExpansion) {
       const { merged } = await this.expandResultsViaGraph({
         memoryResults: results,
@@ -15513,7 +15545,7 @@ ${lines.join("\n\n")}`;
   async flushAccessTracking() {
     if (this.accessTrackingBuffer.size === 0) return;
     const entries = [];
-    const namespaces = this.config.namespacesEnabled ? Array.from(
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? Array.from(
       /* @__PURE__ */ new Set([
         this.config.defaultNamespace,
         this.config.sharedNamespace,
@@ -16169,7 +16201,7 @@ ${lines.join("\n\n")}`;
     return resolved;
   }
   namespaceFromPath(p) {
-    if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return this.config.defaultNamespace;
     const parts = qmdCollectionPathParts(p);
     const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
     if (collectionNamespace) return collectionNamespace;
@@ -16270,4 +16302,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-OUITHS6V.js.map
+//# sourceMappingURL=chunk-Z7J3OAPR.js.map