@remnic/core 9.3.733 → 9.3.735

package/src/orchestrator.ts

@@ -101,6 +101,8 @@ 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 { LifecyclePolicyCoordinator } from "./orchestration/lifecycle-policy-coordinator.js";
 import {
   runLiveConnectorsOnce,
   type LiveConnectorsRunSummary,
@@ -266,6 +268,7 @@ import {
 } from "./trust-zones.js";
 import { tryDirectAnswer, type DirectAnswerSources } from "./direct-answer-wiring.js";
 import {
+  resolveNamespaceCapabilities,
   resolveCapabilities,
   resolveGraphConstructionCapabilities,
   resolveMemoryLifecycleCapabilities,
@@ -276,7 +279,10 @@ import {
   type MemoryLifecycleCapabilitySet,
   type IndexingCapabilitySet,
   type CreationMemoryCapabilitySet,
-} from "./capabilities.js";
+  resolveQmdCapabilities,
+  resolveIdentityContinuityCapabilities,
+  resolveLocalLlmCapabilities,
+  resolveSecurityCapabilities, resolveEvalCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities, resolveCompressionCapabilities} from "./capabilities.js";
 import { DEFAULT_TAXONOMY } from "./taxonomy/index.js";
 import {
   searchHarmonicRetrieval,
@@ -1896,6 +1902,8 @@ export class Orchestrator {
   readonly tierMigrationStatus: TierMigrationStatusStore;
   readonly tierMigrationCoordinator: TierMigrationCoordinator;
   readonly compressionGuidelineCoordinator: CompressionGuidelineCoordinator;
+  readonly semanticConsolidationCoordinator: SemanticConsolidationCoordinator;
+  readonly lifecyclePolicyCoordinator: LifecyclePolicyCoordinator;
   /**
    * 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 +2259,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 +2339,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 +2362,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 +2566,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 +2589,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 +2608,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 +2660,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 +3027,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 +3070,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(
@@ -3082,6 +3100,16 @@ export class Orchestrator {
       config.gatewayConfig,
       this.modelRegistry,
     );
+    this.lifecyclePolicyCoordinator = new LifecyclePolicyCoordinator({
+      config,
+      getStorage: () => this.storage,
+      extraction: this.extraction,
+      embeddingFallback: this.embeddingFallback,
+      getEffectiveLifecycleThresholds: () => this.effectiveLifecycleThresholds(),
+      removeContentHashForMemory: (targetStorage, memory, context) =>
+        this.removeContentHashForMemory(targetStorage, memory, context),
+      saveContentHashIndexes: () => this.saveContentHashIndexes(),
+    });
     this.threading = new ThreadingManager(
       path.join(config.memoryDir, "threads"),
       config.threadingGapMinutes,
@@ -3224,7 +3252,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 +3446,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 +3468,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,
@@ -3494,8 +3522,8 @@ export class Orchestrator {
       this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
       this.utilityRuntimeValues = await loadUtilityRuntimeValues({
         memoryDir: this.config.memoryDir,
-        memoryUtilityLearningEnabled: this.config.memoryUtilityLearningEnabled,
-        promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled,
+        memoryUtilityLearningEnabled: resolveUtilityLearningCapabilities(this.config).memoryUtilityLearning,
+        promotionByOutcomeEnabled: resolveUtilityLearningCapabilities(this.config).promotionByOutcome,
       });
 
       // Initialize content-hash dedup index
@@ -3560,14 +3588,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 +3709,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 +3816,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 +3841,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 +3946,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 +3958,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 +4000,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 +4011,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 +4033,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 +4402,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> {
@@ -5144,7 +4817,7 @@ export class Orchestrator {
       action: event.action,
       eligibility,
       options: {
-        actionsEnabled: this.config.contextCompressionActionsEnabled,
+        actionsEnabled: resolveCompressionCapabilities(this.config).contextCompressionActions,
         maxCompressionTokensPerHour: this.config.maxCompressionTokensPerHour,
       },
     });
@@ -5950,7 +5623,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 +6092,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 +6209,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 +6833,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 +7153,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 +7426,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 +7671,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 +8077,7 @@ export class Orchestrator {
       if (
         !this.isRecallSectionEnabled(
           "identity-continuity",
-          this.config.identityContinuityEnabled === true,
+          resolveIdentityContinuityCapabilities(this.config).identityContinuity === true,
         )
       )
         return null;
@@ -8644,11 +8317,11 @@ export class Orchestrator {
     const objectiveStatePromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.objectiveStateMemoryEnabled ||
-        !this.config.objectiveStateRecallEnabled ||
+        !resolveObjectiveStateCapabilities(this.config).objectiveStateMemory ||
+        !resolveObjectiveStateCapabilities(this.config).objectiveStateRecall ||
         !this.isRecallSectionEnabled(
           "objective-state",
-          this.config.objectiveStateRecallEnabled === true,
+          resolveObjectiveStateCapabilities(this.config).objectiveStateRecall === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -8679,17 +8352,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,
@@ -8901,11 +8574,11 @@ export class Orchestrator {
     const trustZonePromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.trustZonesEnabled ||
-        !this.config.trustZoneRecallEnabled ||
+        !resolveSecurityCapabilities(this.config).trustZones ||
+        !resolveSecurityCapabilities(this.config).trustZoneRecall ||
         !this.isRecallSectionEnabled(
           "trust-zones",
-          this.config.trustZoneRecallEnabled === true,
+          resolveSecurityCapabilities(this.config).trustZoneRecall === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -9593,7 +9266,7 @@ export class Orchestrator {
               qmdFetchLimit,
               qmdHybridFetchLimit,
               {
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 recallNamespaces,
                 resolveNamespace: (p) => this.namespaceFromPath(p),
                 queryAwarePrefilter,
@@ -10011,7 +9684,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 +10758,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 +11132,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 +11311,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,
@@ -12074,7 +11747,7 @@ export class Orchestrator {
     if (
       this.isRecallSectionEnabled(
         "compression-guidelines",
-        this.config.compressionGuidelineLearningEnabled === true,
+        resolveCompressionCapabilities(this.config).compressionGuidelineLearning === true,
       )
     ) {
       const compressionGuidelineSection =
@@ -12476,7 +12149,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 +13866,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 +13908,7 @@ export class Orchestrator {
       confidence: number,
     ): boolean => {
       if (
-        !this.config.namespacesEnabled ||
+        !resolveNamespaceCapabilities(this.config).namespaces ||
         !profileAllowsSharedWrites ||
         !sharedAutoPromotionAllows(category, confidence)
       )
@@ -16769,7 +16442,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>([
@@ -17356,81 +17029,6 @@ export class Orchestrator {
     return this.compressionGuidelineCoordinator.buildCompressionGuidelineRecallSection();
   }
 
-  private actionOutcomePriorDelta(event: MemoryActionEvent): number {
-    if (event.outcome === "failed") return -0.3;
-    if (event.policyDecision === "deny") return -0.22;
-    if (event.policyDecision === "defer") return -0.14;
-    if (event.outcome === "skipped") return -0.1;
-
-    if (event.outcome !== "applied") return 0;
-    switch (event.action) {
-      case "store_episode":
-      case "store_note":
-      case "update_note":
-        return 0.08;
-      case "create_artifact":
-      case "summarize_node":
-      case "link_graph":
-        return 0.04;
-      case "discard":
-        return -0.03;
-      default:
-        return 0;
-    }
-  }
-
-  private async buildLifecycleActionPriors(
-    storage: StorageManager = this.storage,
-  ): Promise<Map<string, number>> {
-    const events = await storage.readMemoryActionEvents(1200);
-    if (events.length === 0) return new Map<string, number>();
-
-    const nowMs = Date.now();
-    const windowMs = 14 * 24 * 60 * 60 * 1000;
-    const byMemory = new Map<
-      string,
-      Array<{ weightedDelta: number; weight: number }>
-    >();
-
-    for (const event of events) {
-      if (
-        typeof event.memoryId !== "string" ||
-        event.memoryId.trim().length === 0
-      )
-        continue;
-      const ts = Date.parse(event.timestamp);
-      if (!Number.isFinite(ts)) continue;
-      const ageMs = nowMs - ts;
-      if (ageMs < 0 || ageMs > windowMs) continue;
-
-      const delta = this.actionOutcomePriorDelta(event);
-      if (delta === 0) continue;
-
-      const recencyWeight = Math.max(0.2, 1 - ageMs / windowMs);
-      const list = byMemory.get(event.memoryId) ?? [];
-      if (list.length >= 8) list.shift();
-      list.push({
-        weightedDelta: delta * recencyWeight,
-        weight: recencyWeight,
-      });
-      byMemory.set(event.memoryId, list);
-    }
-
-    const out = new Map<string, number>();
-    for (const [memoryId, deltas] of byMemory.entries()) {
-      if (deltas.length === 0) continue;
-      const weightedSum = deltas.reduce(
-        (sum, item) => sum + item.weightedDelta,
-        0,
-      );
-      const weightTotal = deltas.reduce((sum, item) => sum + item.weight, 0);
-      if (weightTotal <= 0) continue;
-      const score = weightedSum / weightTotal;
-      out.set(memoryId, Math.max(-0.25, Math.min(0.15, score)));
-    }
-    return out;
-  }
-
   private async recordScheduledDreamsPhaseRun(
     phase: "lightSleep" | "rem" | "deepSleep",
     itemsProcessed: number,
@@ -17465,315 +17063,23 @@ export class Orchestrator {
     allMemories: MemoryFile[],
     storage: StorageManager = this.storage,
   ): Promise<number> {
-    const now = new Date();
-    const nowIso = now.toISOString();
-    const countsByState: Record<LifecycleState, number> = {
-      candidate: 0,
-      validated: 0,
-      active: 0,
-      stale: 0,
-      archived: 0,
-    };
-    const transitionCounts: Record<string, number> = {};
-    let updatedCount = 0;
-    let disputedCount = 0;
-    let evaluatedCount = 0;
-    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-
-    const thresholds = this.effectiveLifecycleThresholds();
-    const policy = {
-      promoteHeatThreshold: thresholds.promoteHeatThreshold,
-      staleDecayThreshold: thresholds.staleDecayThreshold,
-      archiveDecayThreshold: thresholds.archiveDecayThreshold,
-      protectedCategories: this.config.lifecycleProtectedCategories,
-    };
-    const actionPriors = await this.buildLifecycleActionPriors(storage);
-
-    for (const memory of allMemories) {
-      if (
-        memory.frontmatter.status === "superseded" ||
-        memory.frontmatter.status === "forgotten"
-      ) {
-        continue;
-      }
-      evaluatedCount += 1;
-      const currentState = resolveLifecycleState(memory.frontmatter);
-      const actionPriorScore = actionPriors.get(memory.frontmatter.id);
-      const signals: LifecycleSignals | undefined =
-        typeof actionPriorScore === "number" &&
-        Number.isFinite(actionPriorScore)
-          ? { actionPriorScore }
-          : undefined;
-      const decision = decideLifecycleTransition(memory, policy, now, signals);
-      const nextState: LifecycleState =
-        memory.frontmatter.status === "archived"
-          ? "archived"
-          : decision.nextState;
-
-      countsByState[nextState] += 1;
-      if (memory.frontmatter.verificationState === "disputed") {
-        disputedCount += 1;
-      }
-      if (nextState !== currentState) {
-        const key = `${currentState}->${nextState}`;
-        transitionCounts[key] = (transitionCounts[key] ?? 0) + 1;
-      }
-
-      const prevHeat = memory.frontmatter.heatScore;
-      const prevDecay = memory.frontmatter.decayScore;
-      const scoreDelta =
-        Math.abs((prevHeat ?? -1) - decision.heatScore) +
-        Math.abs((prevDecay ?? -1) - decision.decayScore);
-      const shouldPersist =
-        memory.frontmatter.lifecycleState !== nextState ||
-        memory.frontmatter.heatScore === undefined ||
-        memory.frontmatter.decayScore === undefined ||
-        memory.frontmatter.lastValidatedAt === undefined ||
-        scoreDelta >= 0.01;
-
-      if (!shouldPersist) continue;
-
-      const wrote = await storage.writeMemoryFrontmatter(memory, {
-        lifecycleState: nextState,
-        heatScore: decision.heatScore,
-        decayScore: decision.decayScore,
-        lastValidatedAt: nowIso,
-      });
-      if (wrote) updatedCount += 1;
-    }
-
-    // Report how many memories had frontmatter rewritten so callers can record a
-    // catalog write touch for lifecycle-only passes (codex NR-tS).
-    if (!lifecycleCaps.lifecycleMetrics) return updatedCount;
-
-    const total = evaluatedCount;
-    const metrics = {
-      generatedAt: nowIso,
-      memoriesEvaluated: total,
-      memoriesUpdated: updatedCount,
-      countsByLifecycleState: countsByState,
-      transitionCounts,
-      staleRatio: total > 0 ? countsByState.stale / total : 0,
-      disputedRatio: total > 0 ? disputedCount / total : 0,
-      policy: {
-        promoteHeatThreshold: thresholds.promoteHeatThreshold,
-        staleDecayThreshold: thresholds.staleDecayThreshold,
-        archiveDecayThreshold: thresholds.archiveDecayThreshold,
-        protectedCategories: this.config.lifecycleProtectedCategories,
-      },
-    };
-    const metricsPath = path.join(
-      storage.dir,
-      "state",
-      "lifecycle-metrics.json",
-    );
-    await mkdir(path.dirname(metricsPath), { recursive: true });
-    await writeFile(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
-    return updatedCount;
+    return this.lifecyclePolicyCoordinator.runLifecyclePolicyPass(allMemories, storage);
   }
-
-  /**
-   * Archive old, low-importance, rarely-accessed facts (v6.0).
-   * Moves eligible facts from facts/ to archive/YYYY-MM-DD/.
-   * Returns the number of archived facts.
-   */
   private async runFactArchival(
     allMemories: import("./types.js").MemoryFile[],
   ): Promise<number> {
-    const now = Date.now();
-    const ageCutoffMs = this.config.factArchivalAgeDays * 24 * 60 * 60 * 1000;
-    const protectedCategories = new Set(
-      this.config.factArchivalProtectedCategories,
-    );
-    let archivedCount = 0;
-
-    for (const memory of allMemories) {
-      const fm = memory.frontmatter;
-
-      // Skip already-archived or superseded
-      if (fm.status && fm.status !== "active") continue;
-
-      // Skip protected categories
-      if (protectedCategories.has(fm.category)) continue;
-
-      // Skip corrections (always keep)
-      if (fm.category === "correction") continue;
-
-      // Check age requirement
-      const createdMs = new Date(fm.created).getTime();
-      if (now - createdMs < ageCutoffMs) continue;
-
-      // Check importance (only archive low-importance facts)
-      const importanceScore = fm.importance?.score ?? 0.5;
-      if (importanceScore >= this.config.factArchivalMaxImportance) continue;
-
-      // Check access count
-      const accessCount = fm.accessCount ?? 0;
-      if (accessCount > this.config.factArchivalMaxAccessCount) continue;
-
-      // All criteria met — archive
-      const result = await this.storage.archiveMemory(memory);
-      if (result) {
-        // Remove from the same storage-scoped content-hash index since it is
-        // no longer in hot search.
-        await this.removeContentHashForMemory(
-          this.storage,
-          memory,
-          "fact-archival",
-        );
-        await this.embeddingFallback.removeFromIndex(memory.frontmatter.id);
-        if (
-          resolveIndexingCapabilities(this.config).queryAwareIndexing &&
-          memory.path &&
-          memory.frontmatter?.created
-        ) {
-          deindexMemory(
-            this.config.memoryDir,
-            memory.path,
-            memory.frontmatter.created,
-            memory.frontmatter.tags ?? [],
-          );
-        }
-        archivedCount++;
-      }
-    }
-
-    // Save hash indexes if we removed any entries.
-    if (archivedCount > 0) {
-      await this.saveContentHashIndexes().catch((err) =>
-        log.warn(`content-hash index save failed during archival: ${err}`),
-      );
-    }
-
-    return archivedCount;
+    return this.lifecyclePolicyCoordinator.runFactArchival(allMemories);
   }
-
-  /**
-   * Run memory summarization if memory count exceeds threshold (Phase 4A).
-   */
   private async runSummarization(
     allMemories: import("./types.js").MemoryFile[],
   ): Promise<void> {
-    // Only active memories count toward the threshold
-    const activeMemories = allMemories.filter(
-      (m) => isActiveMemoryStatus(m.frontmatter.status),
-    );
-
-    if (activeMemories.length < this.config.summarizationTriggerCount) {
-      return;
-    }
-
-    log.info(
-      `memory count (${activeMemories.length}) exceeds threshold (${this.config.summarizationTriggerCount}) — running summarization`,
-    );
-
-    // Sort by creation date, oldest first
-    const sorted = activeMemories.sort(
-      (a, b) =>
-        new Date(a.frontmatter.created).getTime() -
-        new Date(b.frontmatter.created).getTime(),
-    );
-
-    // Keep recent memories, with explicit zero handling so `slice(-0)` does not
-    // accidentally keep every memory out of the summarization candidate set.
-    const recentToKeep = Math.max(0, this.config.summarizationRecentToKeep);
-    const toSummarize = recentToKeep > 0 ? sorted.slice(0, -recentToKeep) : sorted;
-
-    // Filter candidates for summarization
-    const candidates = toSummarize.filter((m) => {
-      // Skip if protected by entity reference
-      if (m.frontmatter.entityRef) return false;
-
-      // Skip if protected by tag
-      const protectedTags = this.config.summarizationProtectedTags;
-      if (m.frontmatter.tags.some((t) => protectedTags.includes(t)))
-        return false;
-
-      // Skip if importance is above threshold
-      const importance = m.frontmatter.importance?.score ?? 0.5;
-      if (importance >= this.config.summarizationImportanceThreshold)
-        return false;
-
-      return true;
-    });
-
-    if (candidates.length < 50) {
-      log.debug(
-        `only ${candidates.length} candidates for summarization — skipping`,
-      );
-      return;
-    }
-
-    // Summarize in batches of 50
-    const batchSize = 50;
-    for (let i = 0; i < candidates.length; i += batchSize) {
-      const batch = candidates.slice(i, i + batchSize);
-      const batchData = batch.map((m) => ({
-        id: m.frontmatter.id,
-        content: m.content,
-        category: m.frontmatter.category,
-        created: m.frontmatter.created,
-      }));
-
-      const result = await this.extraction.summarizeMemories(batchData);
-      if (!result) continue;
-
-      // Create summary
-      const summary: MemorySummary = {
-        id: `summary-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-        createdAt: new Date().toISOString(),
-        timeRangeStart: batch[0].frontmatter.created,
-        timeRangeEnd: batch[batch.length - 1].frontmatter.created,
-        summaryText: result.summaryText,
-        keyFacts: result.keyFacts,
-        keyEntities: result.keyEntities,
-        sourceEpisodeIds: batch.map((m) => m.frontmatter.id),
-      };
-
-      await this.storage.writeSummary(summary);
-
-      // Archive source memories
-      const archived = await this.storage.archiveMemories(
-        batch.map((m) => m.frontmatter.id),
-        summary.id,
-      );
-
-      // Catalog write touch (issue #1499 sweep): summarization writes a durable
-      // summary and then rewrites source-memory archive status, bypassing the
-      // extraction write path. Record the touch after both mutations complete so
-      // `lastWriteAt` covers the final archived-state write.
-      // #1522: catalog touch handled at the storage chokepoint.
-
-      log.info(
-        `created summary ${summary.id} from ${batch.length} memories, archived ${archived}`,
-      );
-    }
+    return this.lifecyclePolicyCoordinator.runSummarization(allMemories);
   }
-
-  /**
-   * Run topic extraction on all memories (Phase 4B).
-   */
   private async runTopicExtraction(
     allMemories: import("./types.js").MemoryFile[],
   ): Promise<void> {
-    // Only extract from active memories
-    const activeMemories = allMemories.filter(
-      (m) => isActiveMemoryStatus(m.frontmatter.status),
-    );
-
-    if (activeMemories.length === 0) return;
-
-    const topics = extractTopics(
-      activeMemories,
-      this.config.topicExtractionTopN,
-    );
-    await this.storage.saveTopics(topics);
-
-    log.debug(
-      `extracted ${topics.length} topics from ${activeMemories.length} memories`,
-    );
+    return this.lifecyclePolicyCoordinator.runTopicExtraction(allMemories);
   }
-
   /** Threshold (bytes) at which IDENTITY.md reflections get auto-consolidated */
   private static readonly IDENTITY_CONSOLIDATE_THRESHOLD = 8_000;
 
@@ -17782,14 +17088,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 +17444,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({
@@ -18227,7 +17533,7 @@ export class Orchestrator {
   private queueEvalShadowRecall(
     record: Omit<EvalShadowRecallRecord, "schemaVersion">,
   ): void {
-    if (!this.config.evalHarnessEnabled || !this.config.evalShadowModeEnabled)
+    if (!resolveEvalCapabilities(this.config).evalHarness || !resolveEvalCapabilities(this.config).evalShadowMode)
       return;
     this.evalShadowWriteChain = this.evalShadowWriteChain
       .catch(() => undefined)
@@ -18344,7 +17650,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 +17777,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 +18336,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 +18573,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 +18618,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 +18665,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 +18723,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 +18926,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 +19886,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)