@remnic/core 9.3.733 → 9.3.734

package/src/orchestrator.ts

@@ -101,6 +101,7 @@ import { MaintenanceScheduler } from "./orchestration/maintenance.js";
 import { TierMigrationCoordinator } from "./orchestration/tier-migration-coordinator.js";
 import { ExtractionQueueCoordinator } from "./orchestration/extraction-queue-coordinator.js";
 import { CompressionGuidelineCoordinator } from "./orchestration/compression-guideline-coordinator.js";
+import { SemanticConsolidationCoordinator } from "./orchestration/semantic-consolidation-coordinator.js";
 import {
   runLiveConnectorsOnce,
   type LiveConnectorsRunSummary,
@@ -266,6 +267,7 @@ import {
 } from "./trust-zones.js";
 import { tryDirectAnswer, type DirectAnswerSources } from "./direct-answer-wiring.js";
 import {
+  resolveNamespaceCapabilities,
   resolveCapabilities,
   resolveGraphConstructionCapabilities,
   resolveMemoryLifecycleCapabilities,
@@ -276,6 +278,9 @@ import {
   type MemoryLifecycleCapabilitySet,
   type IndexingCapabilitySet,
   type CreationMemoryCapabilitySet,
+  resolveQmdCapabilities,
+  resolveIdentityContinuityCapabilities,
+  resolveLocalLlmCapabilities,
 } from "./capabilities.js";
 import { DEFAULT_TAXONOMY } from "./taxonomy/index.js";
 import {
@@ -1896,6 +1901,7 @@ export class Orchestrator {
   readonly tierMigrationStatus: TierMigrationStatusStore;
   readonly tierMigrationCoordinator: TierMigrationCoordinator;
   readonly compressionGuidelineCoordinator: CompressionGuidelineCoordinator;
+  readonly semanticConsolidationCoordinator: SemanticConsolidationCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -2251,7 +2257,7 @@ export class Orchestrator {
    * @internal
    */
   applyCodingNamespaceOverlay(sessionKey: string | undefined, baseNamespace: string): string {
-    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;
@@ -2331,7 +2337,7 @@ export class Orchestrator {
    * @internal
    */
   applyCodingRecallOverlay(sessionKey: string | undefined): { namespace: string; readFallbacks: string[] } | null {
-    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;
@@ -2354,7 +2360,7 @@ export class Orchestrator {
   }
 
   private rememberNamespaceStorageDirHint(namespace: string, storageDir?: string): void {
-    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);
@@ -2558,10 +2564,10 @@ export class Orchestrator {
   private buildConfiguredQmdSearchOptions(
     queryText: string,
   ): SearchQueryOptions | undefined {
-    const intentHint = this.config.qmdIntentHintsEnabled
+    const intentHint = resolveQmdCapabilities(this.config).qmdIntentHints
       ? buildQmdIntentHint(inferIntentFromText(queryText))
       : undefined;
-    const explain = this.config.qmdExplainEnabled === true;
+    const explain = resolveQmdCapabilities(this.config).qmdExplain === true;
     const searchOptions: SearchQueryOptions = {};
     if (intentHint) {
       searchOptions.intent = intentHint;
@@ -2581,13 +2587,13 @@ export class Orchestrator {
     execution?: SearchExecutionOptions;
   }): Promise<QmdSearchResult[]> {
     if (
-      this.config.namespacesEnabled &&
+      resolveNamespaceCapabilities(this.config).namespaces &&
       options.namespaces !== undefined &&
       options.namespaces.length === 0
     ) {
       return [];
     }
-    const namespaces = this.config.namespacesEnabled
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces
       ? Array.from(
           new Set(
             (options.namespaces?.length
@@ -2600,7 +2606,7 @@ export class Orchestrator {
         )
       : [this.config.defaultNamespace];
 
-    if (!this.config.namespacesEnabled) {
+    if (!resolveNamespaceCapabilities(this.config).namespaces) {
       switch (options.mode) {
         case "hybrid":
           return await this.qmd.hybridSearch(
@@ -2652,7 +2658,7 @@ export class Orchestrator {
   }
 
   private isSearchAvailableForNamespaceRouting(): boolean {
-    if (this.config.namespacesEnabled) return true;
+    if (resolveNamespaceCapabilities(this.config).namespaces) return true;
     return this.qmd.isAvailable();
   }
 
@@ -3019,6 +3025,7 @@ export class Orchestrator {
       fastChatCompletion: (messages, options) =>
         this.fastChatCompletion(messages, options),
     });
+
     this.sessionObserver = new SessionObserverState({
       memoryDir: config.memoryDir,
       debounceMs: config.sessionObserverDebounceMs ?? 120_000,
@@ -3061,6 +3068,15 @@ export class Orchestrator {
           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(),
+    });
     // Initialize gateway fast LLM for fast-tier ops when modelSource is "gateway"
     this._fastGatewayLlm = config.modelSource === "gateway"
       ? new FallbackLlmClient(
@@ -3224,7 +3240,7 @@ export class Orchestrator {
   }
 
   private routeEngineOptions(): RoutingEngineOptions {
-    const allowedNamespaces = this.config.namespacesEnabled
+    const allowedNamespaces = resolveNamespaceCapabilities(this.config).namespaces
       ? Array.from(
           new Set([
             this.config.defaultNamespace,
@@ -3418,7 +3434,7 @@ export class Orchestrator {
         ? this._fastGatewayLlm?.isAvailable(
             this.config.fastGatewayAgentId || this.config.gatewayAgentId || undefined,
           ) === true
-        : this.config.localLlmEnabled;
+        : resolveLocalLlmCapabilities(this.config).localLlm;
     if (!chainAvailable) return undefined;
     return buildChainFollowupGenerator(this.fastLlmForRerank);
   }
@@ -3440,7 +3456,7 @@ export class Orchestrator {
       });
       await this.storage.ensureDirectories();
       await this.storage.loadAliases();
-      if (this.config.namespacesEnabled) {
+      if (resolveNamespaceCapabilities(this.config).namespaces) {
         const namespaces = new Set<string>([
           this.config.defaultNamespace,
           this.config.sharedNamespace,
@@ -3560,14 +3576,14 @@ export class Orchestrator {
           // after a restart. `registerConfiguredNamespaces()` already seeded the
           // catalog above, so `maintenanceNamespaces()` is readable here; it falls
           // back to the configured set on any catalog read failure.
-          const namespaces = this.config.namespacesEnabled
+          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
+                resolveNamespaceCapabilities(this.config).namespaces
                   ? this.namespaceSearchRouter.ensureNamespaceCollection(
                       namespace,
                       { signal: collectionCheckAbort.signal },
@@ -3681,10 +3697,10 @@ export class Orchestrator {
     // triggered update — which can be days ago if the daemon restarted without
     // new extractions. This is the root cause of "0 memories" recall results
     // despite thousands of facts on disk.
-    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) {
           // Cover cataloged dynamic namespaces at startup too (NHZEV, codex P2):
           // a dynamic namespace written before a daemon restart must be synced on
           // boot, not only by the debounced runQmdMaintenance() path. Same union +
@@ -3788,7 +3804,7 @@ export class Orchestrator {
 
     if (signal.aborted) return;
 
-    if (this.config.localLlmEnabled) {
+    if (resolveLocalLlmCapabilities(this.config).localLlm) {
       try {
         await this.validateLocalLlmModel();
       } catch (err) {
@@ -3813,7 +3829,7 @@ export class Orchestrator {
     // sweep (capped at 50 demotions) so the hot tier isn't flooded on the
     // first real cron pass. Non-fatal — a failure here must not break init.
     if (signal.aborted) return;
-    if (lifecycleCaps.lifecyclePolicy && this.config.qmdTierMigrationEnabled) {
+    if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.config).qmdTierMigration) {
       try {
         const { runFirstStartMigration } = await import(
           "./maintenance/first-start-migration.js"
@@ -3918,7 +3934,7 @@ export class Orchestrator {
     log.info(`startupSearchSync: backend now available ${this.qmd.debugStatus()}`);
 
     // Clear namespace router cache so re-probe picks up newly available backends
-    if (this.config.namespacesEnabled) {
+    if (resolveNamespaceCapabilities(this.config).namespaces) {
       this.namespaceSearchRouter.clearCache();
     }
 
@@ -3930,14 +3946,14 @@ export class Orchestrator {
     // re-synced here too, otherwise after a backend-was-unavailable-at-boot
     // recovery its collection stays stale. Falls back to the configured set on any
     // catalog read failure.
-    const namespaces = this.config.namespacesEnabled
+    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
+        state: resolveNamespaceCapabilities(this.config).namespaces
           ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace, { signal })
           : await this.qmd.ensureCollection(this.config.memoryDir, this.config.qmdCollection, { signal }),
       })),
@@ -3972,7 +3988,7 @@ export class Orchestrator {
     // and didn't fail silently.
     // The abort signal is forwarded into the QMD subprocess call so the
     // long-running `qmd update` process is killed promptly on shutdown.
-    if (this.config.qmdMaintenanceEnabled) {
+    if (resolveQmdCapabilities(this.config).qmdMaintenance) {
       try {
         const failTsBefore = "lastUpdateFailedAtMs" in this.qmd
           ? (this.qmd as any).lastUpdateFailedAtMs as number | null
@@ -3983,7 +3999,7 @@ export 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 },
@@ -4005,7 +4021,7 @@ export 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;
@@ -4374,372 +4390,17 @@ export class Orchestrator {
     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.
   private async runSemanticConsolidation(options?: {
     dryRun?: boolean;
     thresholdOverride?: number;
     force?: boolean;
     storage?: StorageManager;
   }): Promise<SemanticConsolidationResult> {
-    const targetStorage = options?.storage ?? this.storage;
-    const result: SemanticConsolidationResult = {
-      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 — skipping LLM synthesis and archival",
-      );
-      return result;
-    }
-
-    // Use FallbackLlmClient for LLM calls (same pattern as causal-consolidation.ts)
-    // Honor semanticConsolidationModel: "auto" = primary, "fast" = local fast, or specific model
-    const { FallbackLlmClient, gatewayTaskChainOptions } = 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");
-    }
-    // Gateway routing: an explicit "fast" setting keeps the fast persona chain
-    // (the operator's deliberate fast-tier choice). Otherwise route through the
-    // shared task-chain resolution so taskModelChain applies to semantic
-    // consolidation like every other background task (gotcha #22). Issue #1365.
-    const gatewayChainOptions: { modelChain?: AgentPersonaModelConfig; agentId?: string } =
-      !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.fastLlm && !useGateway)) {
-      log.warn(
-        "[semantic-consolidation] no LLM available — skipping synthesis",
-      );
-      return result;
-    }
-
-    // Discover memory extensions once for all clusters (#382)
-    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 {
-        // Operator-aware prompt (issue #561 PR 3): ask the LLM to pick the
-        // SPLIT/MERGE/UPDATE operator alongside the canonical output.  Falls
-        // back to the legacy plain-blob prompt when operator-aware
-        // consolidation is explicitly disabled via config, so rollbacks stay
-        // clean.
-        // Use the `=== true` idiom for default-false flags (PR #632
-        // review, cursor Low): sibling disabled-by-default flags like
-        // `semanticConsolidationEnabled` follow the same convention,
-        // while `!== false` is reserved for default-on flags.
-        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" as const,
-            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" — 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" as const, content: prompt },
-        ];
-        const llmOpts = { temperature: 0.2, maxTokens: 2000 };
-
-        // Route to the configured model
-        let response: { content: string } | null = null;
-        if (useGateway) {
-          // Gateway model source — use the appropriate agent chain
-          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;
-        }
-
-        // Operator-aware parse (issue #561 PR 3).  In legacy mode we fall
-        // back to the plain-text parser and derive the operator from the
-        // cluster-shape heuristic so `derived_via` still lands.
-        // Restricted to `SemanticConsolidationLlmOperator`
-        // (split/merge/update) — `pattern-reinforcement` joined the
-        // wider `ConsolidationOperator` type in #687 PR 2/4 but is
-        // reserved for the maintenance job and must never be assignable
-        // here (Cursor Bugbot review, PR #730).
-        let canonicalContent: string;
-        let operator: SemanticConsolidationLlmOperator;
-        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;
-
-        // Pick the most recent memory's metadata as the basis for lineage
-        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);
-
-        // Consolidation provenance (issue #561 PR 2+3): snapshot each
-        // source memory BEFORE archiving it, collecting
-        // "<relpath>:<versionId>" pointers for the new canonical memory's
-        // `derived_from` frontmatter field.  Snapshots are best-effort — if
-        // page-versioning is disabled (default in `config.ts`) or a single
-        // source fails to snapshot we simply omit that entry rather than
-        // abort the consolidation.  The `derived_via` operator is chosen
-        // above (PR 3) from the LLM response or the cluster-shape
-        // heuristic fallback and emitted unconditionally so consolidation
-        // outputs stay identifiable even when no snapshots are captured
-        // (PR #624 review feedback).
-        const derivedFromEntries: string[] = [];
-        for (const m of cluster.memories) {
-          if (!m.path) continue;
-          const entry = await targetStorage.snapshotForProvenance(m.path);
-          if (entry) derivedFromEntries.push(entry);
-        }
-
-        // Write the canonical memory
-        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 : undefined,
-            derivedVia: operator,
-          },
-        );
-        if (canonicalBlocked) {
-          // #1645: canonical matched a tombstone (pending_review). Don't archive
-          // the sources — consolidation must never delete the only active copy.
-          log.info(`[semantic-consolidation] cluster in "${cluster.category}" tombstone-blocked — keeping ${cluster.memories.length} source(s) active (pending_review ${canonicalId})`);
-          continue;
-        }
-        canonicalWriteCompleted = true;
-
-        result.memoriesConsolidated++;
-
-        // Archive originals
-        for (const m of cluster.memories) {
-          const archiveResult = await targetStorage.archiveMemory(m, {
-            actor: "semantic-consolidation",
-            reasonCode: "semantic-consolidation",
-            relatedMemoryIds: [canonicalId],
-          });
-          if (archiveResult) {
-            // Remove from the same storage-scoped content-hash index that
-            // originally deduped this memory.
-            await this.removeContentHashForMemory(
-              targetStorage,
-              m,
-              "semantic-consolidation",
-            );
-            // Best-effort index cleanup: a failure here (e.g. on-disk index save
-            // under disk-full) must NOT abort the archival loop and thereby skip
-            // the catalog write touch below for an already-durable canonical write
-            // (kilo NV0mh).
-            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 → ${canonicalId}`,
-        );
-      } catch (err) {
-        log.warn(
-          `[semantic-consolidation] cluster processing failed: ${err instanceof Error ? err.message : String(err)}`,
-        );
-        result.errors++;
-      } finally {
-        if (canonicalWriteCompleted) {
-          // Catalog write touch (issue #1499 sweep): record after the canonical
-          // write and, on the happy path, after archival of superseded cluster
-          // memories, so `lastWriteAt` reflects every durable mutation in this
-          // consolidation (cursor NUtCK). The `finally` also covers partial
-          // failures where the canonical memory was written but a later archive
-          // step throws and the cluster catch continues (codex NY-dK).
-          // Best-effort; namespace decoded from the storage dir since this path
-          // #1522: catalog touch handled at the storage chokepoint.
-        }
-      }
-    }
-
-    // Save hash indexes if we modified them.
-    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}`,
-    );
-
-    // #378: fire the Codex materialize post-hook so `codexMaterializeOnConsolidation`
-    // actually has a runtime effect. The helper silently no-ops when the
-    // feature flag or the per-trigger toggle is off, when the sentinel is
-    // missing, or when nothing has changed since the previous run, so it's
-    // safe to always call here. Wrapped in a try/catch because a failed
-    // materialize must never abort the consolidation result — consolidation
-    // is the load-bearing operation; materialization is an optional mirror.
-    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)
-        }`,
-      );
-    }
-
-    // Issue #679 PR 2/5 — async peer profile reasoner runs as part of
-    // the REM phase, immediately after semantic consolidation. Gated
-    // on `peerProfileReasonerEnabled` (default false, opt-in). Wrapped
-    // in a try/catch because reasoner I/O (LLM call, peer-profile
-    // writes) must never abort the consolidation result. The reasoner
-    // itself also defends against partial failure — see profile-reasoner.ts.
-    if (this.config.peerProfileReasonerEnabled) {
-      try {
-        const { runPeerProfileReasoner } = await import("./peers/index.js");
-        const llm = new FallbackLlmClient(
-          this.config.gatewayConfig,
-          fallbackLlmRuntimeContextFromConfig(this.config),
-        );
-        const peerResult = await runPeerProfileReasoner({
-          memoryDir: targetStorage.dir,
-          enabled: true,
-          llm,
-          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: number = 60_000): Promise<boolean> {
@@ -5950,7 +5611,7 @@ export class Orchestrator {
       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");
     }
@@ -6419,7 +6080,7 @@ export class Orchestrator {
     for (const memoryPath of paths) {
       if (!memoryPath || isArtifactMemoryPath(memoryPath)) continue;
       if (
-        this.config.namespacesEnabled &&
+        resolveNamespaceCapabilities(this.config).namespaces &&
         !recallNamespaces.includes(this.namespaceFromPath(memoryPath))
       ) {
         continue;
@@ -6536,7 +6197,7 @@ export class Orchestrator {
     const memories = (
       await Promise.all(
         Array.from(candidatePaths).map(async (memoryPath) => {
-          const namespace = this.config.namespacesEnabled
+          const namespace = resolveNamespaceCapabilities(this.config).namespaces
             ? this.namespaceFromPath(memoryPath)
             : this.config.defaultNamespace;
           const storage = await this.storageRouter.storageFor(namespace);
@@ -7160,7 +6821,7 @@ export class Orchestrator {
   private async resolveStateDirForNamespace(
     namespace: string,
   ): Promise<string> {
-    if (!this.config.namespacesEnabled) {
+    if (!resolveNamespaceCapabilities(this.config).namespaces) {
       return path.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
@@ -7480,7 +7141,7 @@ export class Orchestrator {
     }
     const timings: Record<string, string> = {};
     const profileTraceId = this.profiler.startTrace("recall", sessionKey, {
-      qmdEnabled: this.config.qmdEnabled,
+      qmdEnabled: resolveQmdCapabilities(this.config).qmd,
       rerankEnabled: caps.rerank,
       parallelRetrieval: caps.parallelRetrieval,
     });
@@ -7753,7 +7414,7 @@ export class Orchestrator {
         && 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");
     }
@@ -7998,7 +7659,7 @@ export class Orchestrator {
         retrievalQueryLength: retrievalQuery.length,
         recallMode,
         recallResultLimit,
-        qmdEnabled: this.config.qmdEnabled,
+        qmdEnabled: resolveQmdCapabilities(this.config).qmd,
         qmdAvailable: this.qmd.isAvailable(),
         recallNamespaces: [],
         source: recallSource,
@@ -8404,7 +8065,7 @@ export class Orchestrator {
       if (
         !this.isRecallSectionEnabled(
           "identity-continuity",
-          this.config.identityContinuityEnabled === true,
+          resolveIdentityContinuityCapabilities(this.config).identityContinuity === true,
         )
       )
         return null;
@@ -8679,17 +8340,17 @@ export class Orchestrator {
 
       const objectiveStateSearches = await Promise.all(
         recallNamespaces.map(async (namespace) => {
-          const storage = this.config.namespacesEnabled
+          const storage = resolveNamespaceCapabilities(this.config).namespaces
             ? await this.getStorage(namespace)
             : null;
           return searchObjectiveStateSnapshots({
-            memoryDir: this.config.namespacesEnabled
+            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,
@@ -9593,7 +9254,7 @@ export class Orchestrator {
               qmdFetchLimit,
               qmdHybridFetchLimit,
               {
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 recallNamespaces,
                 resolveNamespace: (p) => this.namespaceFromPath(p),
                 queryAwarePrefilter,
@@ -10011,7 +9672,7 @@ export class Orchestrator {
           workspaceDir: this.config.workspaceDir,
           memoryDir: this.config.memoryDir,
           config: this.config.nativeKnowledge,
-          recallNamespaces: this.config.namespacesEnabled
+          recallNamespaces: resolveNamespaceCapabilities(this.config).namespaces
             ? recallNamespaces
             : undefined,
           defaultNamespace: this.config.defaultNamespace,
@@ -11085,7 +10746,7 @@ export class Orchestrator {
       let memoryResults = memoryResultsRaw;
 
       // Enforce namespace read policies by filtering paths.
-      if (this.config.namespacesEnabled) {
+      if (resolveNamespaceCapabilities(this.config).namespaces) {
         memoryResults = memoryResults.filter((r) =>
           recallNamespaces.includes(this.namespaceFromPath(r.path)),
         );
@@ -11459,7 +11120,7 @@ export class Orchestrator {
             const scopedCandidates = filterRecallCandidates(
               prefilteredEmbeddingResults,
               {
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 recallNamespaces,
                 resolveNamespace: (p) => this.namespaceFromPath(p),
                 limit: embeddingFetchLimit,
@@ -11638,7 +11299,7 @@ export class Orchestrator {
             const scopedCandidates = filterRecallCandidates(
               prefilteredEmbeddingResults,
               {
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 recallNamespaces,
                 resolveNamespace: (p) => this.namespaceFromPath(p),
                 limit: embeddingFetchLimit,
@@ -12476,7 +12137,7 @@ export class Orchestrator {
       retrievalQueryLength: retrievalQuery.length,
       recallMode,
       recallResultLimit,
-      qmdEnabled: this.config.qmdEnabled,
+      qmdEnabled: resolveQmdCapabilities(this.config).qmd,
       qmdAvailable: this.qmd.isAvailable(),
       recallNamespaces,
       source: recallSource,
@@ -14193,7 +13854,7 @@ export class Orchestrator {
     // #1713: hoist namespaces-enabled once for the scope-routing mirrors
     // (pre-judge + write-loop) so no new scattered config.*Enabled read is
     // introduced (ratchet scatteredConfigFlagReads; see #1523).
-    const namespacesEnabled = this.config.namespacesEnabled;
+    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
     const profileAutoPromotionAllows = (
       category: string,
       confidence: number,
@@ -14235,7 +13896,7 @@ export class Orchestrator {
       confidence: number,
     ): boolean => {
       if (
-        !this.config.namespacesEnabled ||
+        !resolveNamespaceCapabilities(this.config).namespaces ||
         !profileAllowsSharedWrites ||
         !sharedAutoPromotionAllows(category, confidence)
       )
@@ -16769,7 +16430,7 @@ export class Orchestrator {
       // On full rebuild with namespaces enabled, span all configured namespaces so
       // memories written to other namespaces before the index existed are also captured.
       const allMemories =
-        needsFullRebuild && this.config.namespacesEnabled
+        needsFullRebuild && resolveNamespaceCapabilities(this.config).namespaces
           ? await this.readAllMemoriesForNamespaces(
               Array.from(
                 new Set<string>([
@@ -17782,14 +17443,14 @@ export class Orchestrator {
     // namespace that accumulated IDENTITY.md reflections must also be eligible for
     // auto-consolidation, otherwise its identity file grows unbounded and is never
     // consolidated. Falls back to the configured set on any catalog read failure.
-    const namespaces = this.config.namespacesEnabled
+    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 &&
+        resolveNamespaceCapabilities(this.config).namespaces &&
         namespace !== this.config.defaultNamespace
           ? namespace
           : undefined;
@@ -18138,7 +17799,7 @@ export class Orchestrator {
     injectedChars: number;
     truncated: boolean;
   } | null> {
-    if (!this.config.identityContinuityEnabled) return null;
+    if (!resolveIdentityContinuityCapabilities(this.config).identityContinuity) return null;
     if (this.config.identityMaxInjectChars <= 0) return null;
 
     const resolved = resolveEffectiveIdentityInjectionMode({
@@ -18344,7 +18005,7 @@ export class Orchestrator {
           : this.config.defaultNamespace;
       if (
         recallNamespaces.length === 0 ||
-        !this.config.namespacesEnabled ||
+        !resolveNamespaceCapabilities(this.config).namespaces ||
         recallNamespaces.includes(fallbackNamespace)
       ) {
         addStorage(fallbackStorage);
@@ -18471,7 +18132,7 @@ export class Orchestrator {
         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 (
@@ -19030,7 +18691,7 @@ export class Orchestrator {
     pathPrefix?: string;
     pathExcludePrefixes?: readonly string[];
   } {
-    if (!this.config.namespacesEnabled) return {};
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
     const memoryDir = path.resolve(this.config.memoryDir);
     const storageDir = path.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
@@ -19267,7 +18928,7 @@ export class Orchestrator {
       }
     };
 
-    const coldQmdEnabled = this.config.qmdColdTierEnabled === true;
+    const coldQmdEnabled = resolveQmdCapabilities(this.config).qmdColdTier === true;
     const coldCollection =
       this.config.qmdColdCollection ?? "openclaw-engram-cold";
     const coldMaxResults =
@@ -19312,7 +18973,7 @@ export class Orchestrator {
               coldFetchLimit,
               coldHybridLimit,
               {
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 recallNamespaces: options.recallNamespaces,
                 resolveNamespace: (p) => this.namespaceFromPath(p),
                 collection: coldCollection,
@@ -19359,7 +19020,7 @@ export class Orchestrator {
     if (longTerm.length === 0) return [];
 
     let results = longTerm;
-    if (this.config.namespacesEnabled) {
+    if (resolveNamespaceCapabilities(this.config).namespaces) {
       const recallRoots: string[] = [];
       const seenRecallRoots = new Set<string>();
       for (const namespace of options.recallNamespaces) {
@@ -19417,13 +19078,13 @@ export class Orchestrator {
     if (results.length === 0) return [];
 
     const isFullModeGraphAssist =
-      this.config.qmdTierParityGraphEnabled &&
+      resolveQmdCapabilities(this.config).qmdTierParityGraph &&
       graphCaps.multiGraphMemory &&
       caps.graphAssistInFullMode &&
       options.recallMode === "full" &&
       results.length >= Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
     const shouldRunGraphExpansion =
-      this.config.qmdTierParityGraphEnabled &&
+      resolveQmdCapabilities(this.config).qmdTierParityGraph &&
       (options.recallMode === "graph_mode" || isFullModeGraphAssist);
 
     if (shouldRunGraphExpansion) {
@@ -19620,7 +19281,7 @@ export class Orchestrator {
 
     // Build entries from buffer, merging with existing counts
     const entries: AccessTrackingEntry[] = [];
-    const namespaces = this.config.namespacesEnabled
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces
       ? Array.from(
           new Set<string>([
             this.config.defaultNamespace,
@@ -20580,7 +20241,7 @@ export class Orchestrator {
   }
 
   private namespaceFromPath(p: string): string {
-    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)