@remnic/core 9.3.733 → 9.3.735

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

@@ -7,10 +7,13 @@ import {
 } from "./chunk-OZECYVGI.js";
 import {
   CompressionGuidelineCoordinator
-} from "./chunk-SYX73XD7.js";
+} from "./chunk-IXGXALRV.js";
 import {
   MaintenanceScheduler
-} from "./chunk-CGPHMNL4.js";
+} from "./chunk-GYICIICQ.js";
+import {
+  runPeerProfileReasoner
+} from "./chunk-I74SUMNI.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
@@ -26,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-ZVHRSR2R.js";
+} from "./chunk-IPI45Q4S.js";
 import {
   SharedContextManager
 } from "./chunk-UFS7OXGL.js";
@@ -60,7 +63,7 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-DKT3X5C3.js";
+} from "./chunk-HFXZIF3V.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -157,7 +160,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-NIZQH6AU.js";
+} from "./chunk-FF36YNKY.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -166,7 +169,7 @@ import {
 } from "./chunk-PWFWCGOO.js";
 import {
   LocalLlmClient
-} from "./chunk-24D66MMN.js";
+} from "./chunk-IX4L7E5G.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -190,12 +193,12 @@ import {
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-P3VJCTVE.js";
+} from "./chunk-CHJIWG2H.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-OTQE66IX.js";
+} from "./chunk-AESC5OQJ.js";
 import {
   RoutingRulesStore
 } from "./chunk-WIWPSQYU.js";
@@ -225,14 +228,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-KSJCXXOU.js";
+} from "./chunk-AE7NTZ75.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-FFUCCKPN.js";
+} from "./chunk-BXPG5AVX.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-ZQUAVZNG.js";
+} from "./chunk-NNJKEAP2.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -330,14 +333,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-J6BH2OBA.js";
+} from "./chunk-GB2FZOWB.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-KQYGNGON.js";
+} from "./chunk-ZBZ4XULO.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-HHNSLPX7.js";
+} from "./chunk-5BOQNB2K.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -360,14 +363,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-PMAQRUN4.js";
-import {
-  resolveCapabilities,
-  resolveCreationMemoryCapabilities,
-  resolveGraphConstructionCapabilities,
-  resolveIndexingCapabilities,
-  resolveMemoryLifecycleCapabilities
-} from "./chunk-ESF7TRYJ.js";
+} from "./chunk-NDKW67ER.js";
 import {
   searchCausalTrajectories
 } from "./chunk-SQNED75R.js";
@@ -469,7 +465,23 @@ import {
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-UZYLX7M6.js";
+} from "./chunk-OYHYBHHI.js";
+import {
+  resolveCapabilities,
+  resolveCompressionCapabilities,
+  resolveCreationMemoryCapabilities,
+  resolveEvalCapabilities,
+  resolveGraphConstructionCapabilities,
+  resolveIdentityContinuityCapabilities,
+  resolveIndexingCapabilities,
+  resolveLocalLlmCapabilities,
+  resolveMemoryLifecycleCapabilities,
+  resolveNamespaceCapabilities,
+  resolveObjectiveStateCapabilities,
+  resolveQmdCapabilities,
+  resolveSecurityCapabilities,
+  resolveUtilityLearningCapabilities
+} from "./chunk-JWDE7OVJ.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule
@@ -494,19 +506,19 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path3 from "path";
+import path4 from "path";
 import os2 from "os";
 import { createHash, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   lstat,
-  mkdir as mkdir2,
+  mkdir as mkdir3,
   readdir,
   readFile as readFile2,
   realpath,
   stat,
   unlink,
-  writeFile as writeFile2
+  writeFile as writeFile3
 } from "fs/promises";
 
 // src/procedural/procedure-recall.ts
@@ -587,7 +599,7 @@ var TierMigrationCoordinator = class {
     const { config, tierMigrationStatus } = this.deps;
     const dryRun = options?.dryRun === true;
     const persistSkipped = options?.force === true || trigger === "manual";
-    if (!config.qmdTierMigrationEnabled && options?.force !== true) {
+    if (!resolveQmdCapabilities(config).qmdTierMigration && options?.force !== true) {
       const skipped = {
         trigger,
         scanned: 0,
@@ -601,7 +613,7 @@ var TierMigrationCoordinator = class {
       if (persistSkipped) await tierMigrationStatus.recordCycle(skipped);
       return skipped;
     }
-    if (trigger === "maintenance" && !config.qmdTierAutoBackfillEnabled && options?.force !== true) {
+    if (trigger === "maintenance" && !resolveQmdCapabilities(config).qmdTierAutoBackfill && options?.force !== true) {
       const skipped = {
         trigger,
         scanned: 0,
@@ -649,7 +661,7 @@ var TierMigrationCoordinator = class {
     }
     const policy = applyUtilityPromotionRuntimePolicy(
       {
-        enabled: config.qmdTierMigrationEnabled,
+        enabled: resolveQmdCapabilities(config).qmdTierMigration,
         demotionMinAgeDays: config.qmdTierDemotionMinAgeDays,
         demotionValueThreshold: config.qmdTierDemotionValueThreshold,
         promotionValueThreshold: config.qmdTierPromotionValueThreshold
@@ -684,7 +696,7 @@ var TierMigrationCoordinator = class {
         qmd: this.deps.getQmd(),
         hotCollection: config.qmdCollection,
         coldCollection: config.qmdColdCollection ?? `${config.qmdCollection}-cold`,
-        autoEmbed: config.qmdAutoEmbedEnabled
+        autoEmbed: resolveQmdCapabilities(config).qmdAutoEmbed
       });
       let migrated = 0;
       let promoted = 0;
@@ -867,8 +879,560 @@ var ExtractionQueueCoordinator = class {
    * drain — used by the flush deadline test to simulate a busy queue and
    * assert a queued task's deadline expires while it waits.
    */
-  setProcessingForTest(value) {
-    this.processing = value;
+  setProcessingForTest(value) {
+    this.processing = value;
+  }
+};
+
+// src/orchestration/semantic-consolidation-coordinator.ts
+var SemanticConsolidationCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  get config() {
+    return this.deps.config;
+  }
+  async runSemanticConsolidation(options) {
+    const targetStorage = options?.storage ?? this.deps.getStorage();
+    const result = {
+      clustersFound: 0,
+      memoriesConsolidated: 0,
+      memoriesArchived: 0,
+      errors: 0,
+      clusters: []
+    };
+    if (!this.config.semanticConsolidationEnabled && !options?.force) {
+      log.debug("[semantic-consolidation] disabled in config");
+      return result;
+    }
+    log.info("[semantic-consolidation] starting run");
+    const allMemories = await targetStorage.readAllMemories();
+    if (allMemories.length < 10) {
+      log.debug("[semantic-consolidation] too few memories, skipping");
+      return result;
+    }
+    const threshold = options?.thresholdOverride ?? this.config.semanticConsolidationThreshold;
+    const clusters = findSimilarClusters(allMemories, {
+      threshold,
+      minClusterSize: this.config.semanticConsolidationMinClusterSize,
+      excludeCategories: this.config.semanticConsolidationExcludeCategories,
+      maxPerRun: this.config.semanticConsolidationMaxPerRun
+    });
+    result.clustersFound = clusters.length;
+    result.clusters = clusters;
+    if (clusters.length === 0) {
+      log.info("[semantic-consolidation] no clusters found");
+      return result;
+    }
+    log.info(`[semantic-consolidation] found ${clusters.length} cluster(s)`);
+    if (options?.dryRun) {
+      log.info(
+        "[semantic-consolidation] dry run \u2014 skipping LLM synthesis and archival"
+      );
+      return result;
+    }
+    const useGateway = this.config.modelSource === "gateway";
+    const modelSetting = this.config.semanticConsolidationModel;
+    if (modelSetting === "fast" && this.deps.getFastLlm() && !useGateway) {
+      log.info("[semantic-consolidation] using fast local LLM for synthesis");
+    }
+    const gatewayChainOptions = !useGateway ? {} : modelSetting === "fast" ? this.config.fastGatewayAgentId ? { agentId: this.config.fastGatewayAgentId } : this.config.gatewayAgentId ? { agentId: this.config.gatewayAgentId } : {} : gatewayTaskChainOptions(this.config);
+    const llm = new FallbackLlmClient(
+      this.config.gatewayConfig,
+      fallbackLlmRuntimeContextFromConfig(this.config)
+    );
+    if (!llm.isAvailable(gatewayChainOptions) && !(modelSetting === "fast" && this.deps.getFastLlm() && !useGateway)) {
+      log.warn(
+        "[semantic-consolidation] no LLM available \u2014 skipping synthesis"
+      );
+      return result;
+    }
+    let extensionsBlock = "";
+    try {
+      extensionsBlock = await buildExtensionsBlockForConsolidation(this.config);
+    } catch (err) {
+      log.warn(`[semantic-consolidation] extension discovery failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    for (const cluster of clusters) {
+      let canonicalWriteCompleted = false;
+      try {
+        const operatorAwareEnabled = this.config.operatorAwareConsolidationEnabled === true;
+        let prompt = operatorAwareEnabled ? buildOperatorAwareConsolidationPrompt(cluster) : buildConsolidationPrompt(cluster);
+        if (extensionsBlock.length > 0) {
+          prompt += "\n\n" + extensionsBlock;
+        }
+        const messages = [
+          {
+            role: "system",
+            content: operatorAwareEnabled ? 'You are a memory consolidation system. Return ONLY a JSON object with two keys, "operator" and "output". The "operator" value MUST be one of the exact strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder, never prose. The "output" value is the canonical memory text.' : "You are a memory consolidation system. Output only the consolidated memory text."
+          },
+          { role: "user", content: prompt }
+        ];
+        const llmOpts = { temperature: 0.2, maxTokens: 2e3 };
+        let response = null;
+        if (useGateway) {
+          response = await llm.chatCompletion(messages, { ...llmOpts, ...gatewayChainOptions });
+        } else if (modelSetting === "fast" && this.deps.getFastLlm()) {
+          const fastResult = await this.deps.getFastLlm().chatCompletion(messages, {
+            operation: "semantic-consolidation",
+            maxTokens: llmOpts.maxTokens,
+            temperature: llmOpts.temperature,
+            priority: "background",
+            forceDisableThinking: true
+          });
+          response = fastResult ? { content: fastResult.content } : null;
+        } else {
+          response = await llm.chatCompletion(messages, llmOpts);
+        }
+        if (!response?.content) {
+          log.warn(
+            `[semantic-consolidation] empty LLM response for cluster in "${cluster.category}"`
+          );
+          result.errors++;
+          continue;
+        }
+        let canonicalContent;
+        let operator;
+        if (operatorAwareEnabled) {
+          const parsed = parseOperatorAwareConsolidationResponse(
+            response.content,
+            cluster
+          );
+          canonicalContent = parsed.output;
+          operator = parsed.operator;
+        } else {
+          canonicalContent = parseConsolidationResponse(response.content);
+          operator = chooseConsolidationOperator(cluster);
+        }
+        cluster.canonicalContent = canonicalContent;
+        const sorted = [...cluster.memories].sort(
+          (a, b) => new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime()
+        );
+        const newest = sorted[0];
+        const lineageIds = cluster.memories.map((m) => m.frontmatter.id);
+        const derivedFromEntries = [];
+        for (const m of cluster.memories) {
+          if (!m.path) continue;
+          const entry = await targetStorage.snapshotForProvenance(m.path);
+          if (entry) derivedFromEntries.push(entry);
+        }
+        const { id: canonicalId, tombstoneBlocked: canonicalBlocked } = await targetStorage.writeMemory(
+          newest.frontmatter.category,
+          canonicalContent,
+          {
+            actor: "semantic-consolidation",
+            confidence: newest.frontmatter.confidence,
+            tags: [
+              ...new Set(
+                cluster.memories.flatMap((m) => m.frontmatter.tags ?? [])
+              )
+            ],
+            source: "semantic-consolidation",
+            lineage: lineageIds,
+            derivedFrom: derivedFromEntries.length > 0 ? derivedFromEntries : void 0,
+            derivedVia: operator
+          }
+        );
+        if (canonicalBlocked) {
+          log.info(`[semantic-consolidation] cluster in "${cluster.category}" tombstone-blocked \u2014 keeping ${cluster.memories.length} source(s) active (pending_review ${canonicalId})`);
+          continue;
+        }
+        canonicalWriteCompleted = true;
+        result.memoriesConsolidated++;
+        for (const m of cluster.memories) {
+          const archiveResult = await targetStorage.archiveMemory(m, {
+            actor: "semantic-consolidation",
+            reasonCode: "semantic-consolidation",
+            relatedMemoryIds: [canonicalId]
+          });
+          if (archiveResult) {
+            await this.deps.removeContentHashForMemory(
+              targetStorage,
+              m,
+              "semantic-consolidation"
+            );
+            try {
+              await this.deps.embeddingFallback.removeFromIndex(m.frontmatter.id);
+              if (resolveIndexingCapabilities(this.config).queryAwareIndexing && m.path && m.frontmatter?.created) {
+                deindexMemory(
+                  targetStorage.dir,
+                  m.path,
+                  m.frontmatter.created,
+                  m.frontmatter.tags ?? []
+                );
+              }
+            } catch (cleanupErr) {
+              log.warn(
+                `[semantic-consolidation] index cleanup failed (non-fatal): ${cleanupErr}`
+              );
+            }
+            result.memoriesArchived++;
+          }
+        }
+        log.info(
+          `[semantic-consolidation] consolidated ${cluster.memories.length} memories \u2192 ${canonicalId}`
+        );
+      } catch (err) {
+        log.warn(
+          `[semantic-consolidation] cluster processing failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        result.errors++;
+      } finally {
+        if (canonicalWriteCompleted) {
+        }
+      }
+    }
+    if (result.memoriesArchived > 0) {
+      await this.deps.saveContentHashIndexes().catch(
+        (err) => log.warn(
+          `[semantic-consolidation] content-hash index save failed: ${err}`
+        )
+      );
+    }
+    log.info(
+      `[semantic-consolidation] complete: clusters=${result.clustersFound}, consolidated=${result.memoriesConsolidated}, archived=${result.memoriesArchived}, errors=${result.errors}`
+    );
+    try {
+      await materializeAfterSemanticConsolidation({
+        config: this.config,
+        memoryDir: targetStorage.dir
+      });
+    } catch (err) {
+      log.warn(
+        `[semantic-consolidation] Codex materialize post-hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (this.config.peerProfileReasonerEnabled) {
+      try {
+        const peerLlm = new FallbackLlmClient(
+          this.config.gatewayConfig,
+          fallbackLlmRuntimeContextFromConfig(this.config)
+        );
+        const peerResult = await runPeerProfileReasoner({
+          memoryDir: targetStorage.dir,
+          enabled: true,
+          llm: peerLlm,
+          model: this.config.peerProfileReasonerModel,
+          minInteractions: this.config.peerProfileReasonerMinInteractions,
+          maxFieldsPerRun: this.config.peerProfileReasonerMaxFieldsPerRun,
+          log: {
+            debug: (msg) => log.debug(msg),
+            info: (msg) => log.info(msg),
+            warn: (msg) => log.warn(msg)
+          }
+        });
+        log.info(
+          `[peer-profile-reasoner] complete: peers=${peerResult.peersConsidered}, processed=${peerResult.peersProcessed}, fields=${peerResult.fieldsApplied}`
+        );
+      } catch (err) {
+        log.warn(
+          `[peer-profile-reasoner] post-consolidation hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return result;
+  }
+};
+
+// src/orchestration/lifecycle-policy-coordinator.ts
+import path2 from "path";
+import { mkdir, writeFile } from "fs/promises";
+var LifecyclePolicyCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  get config() {
+    return this.deps.config;
+  }
+  // -------------------------------------------------------------------------
+  // Action-outcome priors (feeds lifecycle transition decisions)
+  // -------------------------------------------------------------------------
+  actionOutcomePriorDelta(event) {
+    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;
+    }
+  }
+  async buildLifecycleActionPriors(storage = this.deps.getStorage()) {
+    const events = await storage.readMemoryActionEvents(1200);
+    if (events.length === 0) return /* @__PURE__ */ new Map();
+    const nowMs = Date.now();
+    const windowMs = 14 * 24 * 60 * 60 * 1e3;
+    const byMemory = /* @__PURE__ */ new Map();
+    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 = /* @__PURE__ */ new Map();
+    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;
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle policy pass (heat/decay scoring + transition)
+  // -------------------------------------------------------------------------
+  async runLifecyclePolicyPass(allMemories, storage = this.deps.getStorage()) {
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    const countsByState = {
+      candidate: 0,
+      validated: 0,
+      active: 0,
+      stale: 0,
+      archived: 0
+    };
+    const transitionCounts = {};
+    let updatedCount = 0;
+    let disputedCount = 0;
+    let evaluatedCount = 0;
+    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
+    const thresholds = this.deps.getEffectiveLifecycleThresholds();
+    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 = typeof actionPriorScore === "number" && Number.isFinite(actionPriorScore) ? { actionPriorScore } : void 0;
+      const decision = decideLifecycleTransition(memory, policy, now, signals);
+      const nextState = 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 === void 0 || memory.frontmatter.decayScore === void 0 || memory.frontmatter.lastValidatedAt === void 0 || 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;
+    }
+    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 = path2.join(
+      storage.dir,
+      "state",
+      "lifecycle-metrics.json"
+    );
+    await mkdir(path2.dirname(metricsPath), { recursive: true });
+    await writeFile(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    return updatedCount;
+  }
+  // -------------------------------------------------------------------------
+  // Fact archival
+  // -------------------------------------------------------------------------
+  /**
+   * 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.
+   */
+  async runFactArchival(allMemories) {
+    const storage = this.deps.getStorage();
+    const now = Date.now();
+    const ageCutoffMs = this.config.factArchivalAgeDays * 24 * 60 * 60 * 1e3;
+    const protectedCategories = new Set(
+      this.config.factArchivalProtectedCategories
+    );
+    let archivedCount = 0;
+    for (const memory of allMemories) {
+      const fm = memory.frontmatter;
+      if (fm.status && fm.status !== "active") continue;
+      if (protectedCategories.has(fm.category)) continue;
+      if (fm.category === "correction") continue;
+      const createdMs = new Date(fm.created).getTime();
+      if (now - createdMs < ageCutoffMs) continue;
+      const importanceScore = fm.importance?.score ?? 0.5;
+      if (importanceScore >= this.config.factArchivalMaxImportance) continue;
+      const accessCount = fm.accessCount ?? 0;
+      if (accessCount > this.config.factArchivalMaxAccessCount) continue;
+      const result = await storage.archiveMemory(memory);
+      if (result) {
+        await this.deps.removeContentHashForMemory(
+          storage,
+          memory,
+          "fact-archival"
+        );
+        await this.deps.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++;
+      }
+    }
+    if (archivedCount > 0) {
+      await this.deps.saveContentHashIndexes().catch(
+        (err) => log.warn(`content-hash index save failed during archival: ${err}`)
+      );
+    }
+    return archivedCount;
+  }
+  // -------------------------------------------------------------------------
+  // Summarization (Phase 4A)
+  // -------------------------------------------------------------------------
+  /**
+   * Run memory summarization if memory count exceeds threshold (Phase 4A).
+   */
+  async runSummarization(allMemories) {
+    const storage = this.deps.getStorage();
+    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}) \u2014 running summarization`
+    );
+    const sorted = activeMemories.sort(
+      (a, b) => new Date(a.frontmatter.created).getTime() - new Date(b.frontmatter.created).getTime()
+    );
+    const recentToKeep = Math.max(0, this.config.summarizationRecentToKeep);
+    const toSummarize = recentToKeep > 0 ? sorted.slice(0, -recentToKeep) : sorted;
+    const candidates = toSummarize.filter((m) => {
+      if (m.frontmatter.entityRef) return false;
+      const protectedTags = this.config.summarizationProtectedTags;
+      if (m.frontmatter.tags.some((t) => protectedTags.includes(t)))
+        return false;
+      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 \u2014 skipping`
+      );
+      return;
+    }
+    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.deps.extraction.summarizeMemories(batchData);
+      if (!result) continue;
+      const summary = {
+        id: `summary-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        createdAt: (/* @__PURE__ */ 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 storage.writeSummary(summary);
+      const archived = await storage.archiveMemories(
+        batch.map((m) => m.frontmatter.id),
+        summary.id
+      );
+      log.info(
+        `created summary ${summary.id} from ${batch.length} memories, archived ${archived}`
+      );
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Topic extraction (Phase 4B)
+  // -------------------------------------------------------------------------
+  /**
+   * Run topic extraction on all memories (Phase 4B).
+   */
+  async runTopicExtraction(allMemories) {
+    const storage = this.deps.getStorage();
+    const activeMemories = allMemories.filter(
+      (m) => isActiveMemoryStatus(m.frontmatter.status)
+    );
+    if (activeMemories.length === 0) return;
+    const topics = extractTopics(
+      activeMemories,
+      this.config.topicExtractionTopN
+    );
+    await storage.saveTopics(topics);
+    log.debug(
+      `extracted ${topics.length} topics from ${activeMemories.length} memories`
+    );
   }
 };
 
@@ -1204,8 +1768,8 @@ function generateResolverDocument(taxonomy) {
 }
 
 // src/taxonomy/taxonomy-loader.ts
-import { readFile, mkdir, writeFile } from "fs/promises";
-import path2 from "path";
+import { readFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -1303,7 +1867,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path2.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path3.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile(taxonomyPath, "utf-8");
@@ -1353,16 +1917,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path2.join(memoryDir, TAXONOMY_DIR);
-  await mkdir(dir, { recursive: true });
-  const filePath = path2.join(dir, TAXONOMY_FILE);
-  await writeFile(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
+  const dir = path3.join(memoryDir, TAXONOMY_DIR);
+  await mkdir2(dir, { recursive: true });
+  const filePath = path3.join(dir, TAXONOMY_FILE);
+  await writeFile2(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path2.join(memoryDir, TAXONOMY_DIR);
+  return path3.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path2.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path3.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/wearables/registry.ts
@@ -2328,7 +2892,7 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
   }
 }
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path3.isAbsolute(resultPath)) return null;
+  if (!resultPath || path4.isAbsolute(resultPath)) return null;
   const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
@@ -2341,9 +2905,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path3.resolve(storageDir);
+  const storageRoot = path4.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path3.resolve(candidate);
+    const resolved = path4.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -2351,12 +2915,12 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path3.join(storageRoot, normalized));
+    addCandidate(path4.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path3.join(storageRoot, "facts", normalized));
+      addCandidate(path4.join(storageRoot, "facts", normalized));
     }
   };
-  if (path3.isAbsolute(resultPath)) {
+  if (path4.isAbsolute(resultPath)) {
     addCandidate(resultPath);
   } else {
     addRelativeCandidates(resultPath);
@@ -2473,7 +3037,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path3.join(os2.homedir(), ".openclaw", "workspace");
+  return path4.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -2766,11 +3330,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path3.isAbsolute(candidatePath) ? candidatePath : path3.resolve(storageDir, candidatePath);
-  const rel = path3.relative(storageDir, absolutePath);
+  const absolutePath = path4.isAbsolute(candidatePath) ? candidatePath : path4.resolve(storageDir, candidatePath);
+  const rel = path4.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path3.sep).join("/");
+  return rel.split(path4.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -2915,7 +3479,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path3.relative(storageDir, mem.path));
+    pathById.set(id, path4.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -2923,7 +3487,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path3.join(options.storageDir, options.memoryRelPath),
+    path: path4.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -2943,16 +3507,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path3.join("corrections", `${options.memoryId}.md`);
+    return path4.join("corrections", `${options.memoryId}.md`);
   }
   const subtree = categoryDirName(options.category);
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path3.join(subtree, day, `${options.memoryId}.md`);
+    return path4.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path3.join(subtree, `${options.memoryId}.md`);
+  return path4.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -3031,6 +3595,8 @@ var Orchestrator = class _Orchestrator {
   tierMigrationStatus;
   tierMigrationCoordinator;
   compressionGuidelineCoordinator;
+  semanticConsolidationCoordinator;
+  lifecyclePolicyCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -3324,7 +3890,7 @@ var Orchestrator = class _Orchestrator {
    * @internal
    */
   applyCodingNamespaceOverlay(sessionKey, baseNamespace) {
-    if (!this.config.namespacesEnabled) return baseNamespace;
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return baseNamespace;
     const codingContext = this.getCodingContextForSession(sessionKey);
     const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode, this.config.defaultNamespace);
     if (!overlay) return baseNamespace;
@@ -3392,7 +3958,7 @@ var Orchestrator = class _Orchestrator {
    * @internal
    */
   applyCodingRecallOverlay(sessionKey) {
-    if (!this.config.namespacesEnabled) return null;
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return null;
     const codingContext = this.getCodingContextForSession(sessionKey);
     const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode, this.config.defaultNamespace);
     if (!overlay) return null;
@@ -3406,13 +3972,13 @@ var Orchestrator = class _Orchestrator {
     return getConfiguredNamespaces(this.config);
   }
   rememberNamespaceStorageDirHint(namespace, storageDir) {
-    if (!this.config.namespacesEnabled || !storageDir) return;
+    if (!resolveNamespaceCapabilities(this.config).namespaces || !storageDir) return;
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return;
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path3.resolve(storageDir);
+    const resolvedStorageDir = path4.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -3423,21 +3989,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path3.resolve(storageDir);
-    const resolvedMemoryDir = path3.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path4.resolve(storageDir);
+    const resolvedMemoryDir = path4.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path3.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path4.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path3.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path3.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path4.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path4.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path3.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path4.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path3.basename(resolvedStorageDir);
+    const leaf = path4.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -3465,7 +4031,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path3.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path4.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -3502,7 +4068,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path3.resolve(record.storageDir);
+      const resolvedStorageDir = path4.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -3557,8 +4123,8 @@ var Orchestrator = class _Orchestrator {
     return summarizeNamespaceMaintenanceHealth(this.config);
   }
   buildConfiguredQmdSearchOptions(queryText) {
-    const intentHint = this.config.qmdIntentHintsEnabled ? buildQmdIntentHint(inferIntentFromText(queryText)) : void 0;
-    const explain = this.config.qmdExplainEnabled === true;
+    const intentHint = resolveQmdCapabilities(this.config).qmdIntentHints ? buildQmdIntentHint(inferIntentFromText(queryText)) : void 0;
+    const explain = resolveQmdCapabilities(this.config).qmdExplain === true;
     const searchOptions = {};
     if (intentHint) {
       searchOptions.intent = intentHint;
@@ -3569,15 +4135,15 @@ var Orchestrator = class _Orchestrator {
     return Object.keys(searchOptions).length > 0 ? searchOptions : void 0;
   }
   async searchAcrossNamespaces(options) {
-    if (this.config.namespacesEnabled && options.namespaces !== void 0 && options.namespaces.length === 0) {
+    if (resolveNamespaceCapabilities(this.config).namespaces && options.namespaces !== void 0 && options.namespaces.length === 0) {
       return [];
     }
-    const namespaces = this.config.namespacesEnabled ? Array.from(
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? Array.from(
       new Set(
         (options.namespaces?.length ? options.namespaces : this.configuredNamespaceList()).map((value) => value.trim()).filter(Boolean)
       )
     ) : [this.config.defaultNamespace];
-    if (!this.config.namespacesEnabled) {
+    if (!resolveNamespaceCapabilities(this.config).namespaces) {
       switch (options.mode) {
         case "hybrid":
           return await this.qmd.hybridSearch(
@@ -3623,7 +4189,7 @@ var Orchestrator = class _Orchestrator {
     return await this.namespaceSearchRouter.healthForNamespace(namespace, execution);
   }
   isSearchAvailableForNamespaceRouting() {
-    if (this.config.namespacesEnabled) return true;
+    if (resolveNamespaceCapabilities(this.config).namespaces) return true;
     return this.qmd.isAvailable();
   }
   invalidateLiveContentHashIndex() {
@@ -3766,7 +4332,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path3.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path4.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -3835,7 +4401,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path3.join(
+    this.conversationIndexDir = path4.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -3891,6 +4457,14 @@ var Orchestrator = class _Orchestrator {
       client.disableThinking = true;
       return client;
     })() : this.localLlm;
+    this.semanticConsolidationCoordinator = new SemanticConsolidationCoordinator({
+      config,
+      getStorage: () => this.storage,
+      getFastLlm: () => this.fastLlm,
+      embeddingFallback: this.embeddingFallback,
+      removeContentHashForMemory: (targetStorage, memory, context) => this.removeContentHashForMemory(targetStorage, memory, context),
+      saveContentHashIndexes: () => this.saveContentHashIndexes()
+    });
     this._fastGatewayLlm = config.modelSource === "gateway" ? new FallbackLlmClient(
       config.gatewayConfig,
       fallbackLlmRuntimeContextFromConfig(config)
@@ -3907,8 +4481,17 @@ var Orchestrator = 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(
-      path3.join(config.memoryDir, "threads"),
+      path4.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -4003,7 +4586,7 @@ var Orchestrator = class _Orchestrator {
     };
   }
   routeEngineOptions() {
-    const allowedNamespaces = this.config.namespacesEnabled ? Array.from(
+    const allowedNamespaces = resolveNamespaceCapabilities(this.config).namespaces ? Array.from(
       /* @__PURE__ */ new Set([
         this.config.defaultNamespace,
         this.config.sharedNamespace,
@@ -4143,7 +4726,7 @@ var Orchestrator = class _Orchestrator {
   get briefingChainFollowupGenerator() {
     const chainAvailable = this.config.modelSource === "gateway" ? this._fastGatewayLlm?.isAvailable(
       this.config.fastGatewayAgentId || this.config.gatewayAgentId || void 0
-    ) === true : this.config.localLlmEnabled;
+    ) === true : resolveLocalLlmCapabilities(this.config).localLlm;
     if (!chainAvailable) return void 0;
     return buildChainFollowupGenerator(this.fastLlmForRerank);
   }
@@ -4158,7 +4741,7 @@ var Orchestrator = class _Orchestrator {
       });
       await this.storage.ensureDirectories();
       await this.storage.loadAliases();
-      if (this.config.namespacesEnabled) {
+      if (resolveNamespaceCapabilities(this.config).namespaces) {
         const namespaces = /* @__PURE__ */ new Set([
           this.config.defaultNamespace,
           this.config.sharedNamespace,
@@ -4199,8 +4782,8 @@ var Orchestrator = 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
       });
       if (this.config.factDeduplicationEnabled) {
         this.contentHashIndex = this.storage.createContentHashIndex();
@@ -4231,7 +4814,7 @@ var Orchestrator = class _Orchestrator {
           const files = await readdir(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path3.join(wsDir, f);
+            const fp = path4.join(wsDir, f);
             const s = await stat(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink(fp).catch(() => {
@@ -4247,12 +4830,12 @@ var Orchestrator = class _Orchestrator {
         const available = await this.qmd.probe();
         if (available) {
           log.info(`Search backend: available ${this.qmd.debugStatus()}`);
-          const namespaces = this.config.namespacesEnabled ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
+          const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
           const states = await Promise.all(
             namespaces.map(async (namespace) => {
               const collectionCheckAbort = new AbortController();
               const state = await qmdStartupCollectionCheckWithTimeout(
-                this.config.namespacesEnabled ? this.namespaceSearchRouter.ensureNamespaceCollection(
+                resolveNamespaceCapabilities(this.config).namespaces ? this.namespaceSearchRouter.ensureNamespaceCollection(
                   namespace,
                   { signal: collectionCheckAbort.signal }
                 ) : this.qmd.ensureCollection(
@@ -4327,10 +4910,10 @@ var Orchestrator = class _Orchestrator {
   }
   async deferredInitialize(signal) {
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    if (this.qmd.isAvailable() && this.config.qmdMaintenanceEnabled) {
+    if (this.qmd.isAvailable() && resolveQmdCapabilities(this.config).qmdMaintenance) {
       try {
         log.info("QMD startup sync: updating index to match current disk state");
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           await this.namespaceSearchRouter.updateNamespaces(
             await this.maintenanceNamespaces(),
             { signal }
@@ -4414,7 +4997,7 @@ var Orchestrator = class _Orchestrator {
       }
     }
     if (signal.aborted) return;
-    if (this.config.localLlmEnabled) {
+    if (resolveLocalLlmCapabilities(this.config).localLlm) {
       try {
         await this.validateLocalLlmModel();
       } catch (err) {
@@ -4424,9 +5007,9 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     await this.maintenanceScheduler.autoRegisterCrons(signal);
     if (signal.aborted) return;
-    if (lifecycleCaps.lifecyclePolicy && this.config.qmdTierMigrationEnabled) {
+    if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-OOR57AYR.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-2RQYDIZ7.js");
         const result = await runFirstStartMigration({
           storage: this.storage,
           config: this.config,
@@ -4500,14 +5083,14 @@ var Orchestrator = class _Orchestrator {
       return false;
     }
     log.info(`startupSearchSync: backend now available ${this.qmd.debugStatus()}`);
-    if (this.config.namespacesEnabled) {
+    if (resolveNamespaceCapabilities(this.config).namespaces) {
       this.namespaceSearchRouter.clearCache();
     }
-    const namespaces = this.config.namespacesEnabled ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
     const states = await Promise.all(
       namespaces.map(async (namespace) => ({
         namespace,
-        state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace, { signal }) : await this.qmd.ensureCollection(this.config.memoryDir, this.config.qmdCollection, { signal })
+        state: resolveNamespaceCapabilities(this.config).namespaces ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace, { signal }) : await this.qmd.ensureCollection(this.config.memoryDir, this.config.qmdCollection, { signal })
       }))
     );
     if (signal?.aborted) {
@@ -4524,7 +5107,7 @@ var Orchestrator = class _Orchestrator {
       log.warn("startupSearchSync: search collection missing; disabling search (fallback retrieval remains enabled)");
       return false;
     }
-    if (this.config.qmdMaintenanceEnabled) {
+    if (resolveQmdCapabilities(this.config).qmdMaintenance) {
       try {
         const failTsBefore = "lastUpdateFailedAtMs" in this.qmd ? this.qmd.lastUpdateFailedAtMs : null;
         const hasRunTs = "lastUpdateRanAtMs" in this.qmd;
@@ -4533,7 +5116,7 @@ var Orchestrator = class _Orchestrator {
         }
         log.info("startupSearchSync: updating index to match current disk state");
         let namespacesUpdated = 0;
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           namespacesUpdated = await this.namespaceSearchRouter.updateNamespaces(
             namespaces,
             { signal }
@@ -4551,7 +5134,7 @@ var Orchestrator = class _Orchestrator {
           log.warn("startupSearchSync: update silently failed (detected via fail timestamp)");
           return false;
         }
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           if (namespacesUpdated === 0) {
             log.warn("startupSearchSync: no namespace backends were eligible for update (all unavailable or collections missing)");
             return false;
@@ -4740,15 +5323,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path3.isAbsolute(rel) ? rel : path3.join(this.config.workspaceDir, rel);
+        const abs = path4.isAbsolute(rel) ? rel : path4.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path3.join(
+            const archiveDir = path4.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path3.basename(abs);
+            const base = path4.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -4756,7 +5339,7 @@ ${doc.content}` : doc.content,
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile2(abs, newContent, "utf-8");
+            await writeFile3(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -4773,8 +5356,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path3.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir2(path3.dirname(fp), { recursive: true });
+        const fp = path4.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir3(path4.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -4787,7 +5370,7 @@ ${doc.content}` : doc.content,
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile2(fp, existing + block, "utf-8");
+        await writeFile3(fp, existing + block, "utf-8");
       }
     }
   }
@@ -4825,253 +5408,18 @@ ${doc.content}` : doc.content,
           this.storageDirNamespace(targetStorage.dir),
           5
         );
-      } catch (error) {
-        log.debug(`deep-sleep governance: entity synthesis refresh failed after apply: ${error}`);
-      }
-    }
-    return summarizeGovernanceResultForDreams(govResult, options?.dryRun === true);
-  }
-  async runSemanticConsolidation(options) {
-    const targetStorage = options?.storage ?? this.storage;
-    const result = {
-      clustersFound: 0,
-      memoriesConsolidated: 0,
-      memoriesArchived: 0,
-      errors: 0,
-      clusters: []
-    };
-    if (!this.config.semanticConsolidationEnabled && !options?.force) {
-      log.debug("[semantic-consolidation] disabled in config");
-      return result;
-    }
-    log.info("[semantic-consolidation] starting run");
-    const allMemories = await targetStorage.readAllMemories();
-    if (allMemories.length < 10) {
-      log.debug("[semantic-consolidation] too few memories, skipping");
-      return result;
-    }
-    const threshold = options?.thresholdOverride ?? this.config.semanticConsolidationThreshold;
-    const clusters = findSimilarClusters(allMemories, {
-      threshold,
-      minClusterSize: this.config.semanticConsolidationMinClusterSize,
-      excludeCategories: this.config.semanticConsolidationExcludeCategories,
-      maxPerRun: this.config.semanticConsolidationMaxPerRun
-    });
-    result.clustersFound = clusters.length;
-    result.clusters = clusters;
-    if (clusters.length === 0) {
-      log.info("[semantic-consolidation] no clusters found");
-      return result;
-    }
-    log.info(`[semantic-consolidation] found ${clusters.length} cluster(s)`);
-    if (options?.dryRun) {
-      log.info(
-        "[semantic-consolidation] dry run \u2014 skipping LLM synthesis and archival"
-      );
-      return result;
-    }
-    const { FallbackLlmClient: FallbackLlmClient2, gatewayTaskChainOptions: gatewayTaskChainOptions2 } = await import("./fallback-llm.js");
-    const useGateway = this.config.modelSource === "gateway";
-    const modelSetting = this.config.semanticConsolidationModel;
-    if (modelSetting === "fast" && this.fastLlm && !useGateway) {
-      log.info("[semantic-consolidation] using fast local LLM for synthesis");
-    }
-    const gatewayChainOptions = !useGateway ? {} : modelSetting === "fast" ? this.config.fastGatewayAgentId ? { agentId: this.config.fastGatewayAgentId } : this.config.gatewayAgentId ? { agentId: this.config.gatewayAgentId } : {} : gatewayTaskChainOptions2(this.config);
-    const llm = new FallbackLlmClient2(
-      this.config.gatewayConfig,
-      fallbackLlmRuntimeContextFromConfig(this.config)
-    );
-    if (!llm.isAvailable(gatewayChainOptions) && !(modelSetting === "fast" && this.fastLlm && !useGateway)) {
-      log.warn(
-        "[semantic-consolidation] no LLM available \u2014 skipping synthesis"
-      );
-      return result;
-    }
-    let extensionsBlock = "";
-    try {
-      extensionsBlock = await buildExtensionsBlockForConsolidation(this.config);
-    } catch (err) {
-      log.warn(`[semantic-consolidation] extension discovery failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-    }
-    for (const cluster of clusters) {
-      let canonicalWriteCompleted = false;
-      try {
-        const operatorAwareEnabled = this.config.operatorAwareConsolidationEnabled === true;
-        let prompt = operatorAwareEnabled ? buildOperatorAwareConsolidationPrompt(cluster) : buildConsolidationPrompt(cluster);
-        if (extensionsBlock.length > 0) {
-          prompt += "\n\n" + extensionsBlock;
-        }
-        const messages = [
-          {
-            role: "system",
-            content: operatorAwareEnabled ? 'You are a memory consolidation system. Return ONLY a JSON object with two keys, "operator" and "output". The "operator" value MUST be one of the exact strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder, never prose. The "output" value is the canonical memory text.' : "You are a memory consolidation system. Output only the consolidated memory text."
-          },
-          { role: "user", content: prompt }
-        ];
-        const llmOpts = { temperature: 0.2, maxTokens: 2e3 };
-        let response = null;
-        if (useGateway) {
-          response = await llm.chatCompletion(messages, { ...llmOpts, ...gatewayChainOptions });
-        } else if (modelSetting === "fast" && this.fastLlm) {
-          const fastResult = await this.fastLlm.chatCompletion(messages, {
-            operation: "semantic-consolidation",
-            maxTokens: llmOpts.maxTokens,
-            temperature: llmOpts.temperature,
-            priority: "background",
-            forceDisableThinking: true
-          });
-          response = fastResult ? { content: fastResult.content } : null;
-        } else {
-          response = await llm.chatCompletion(messages, llmOpts);
-        }
-        if (!response?.content) {
-          log.warn(
-            `[semantic-consolidation] empty LLM response for cluster in "${cluster.category}"`
-          );
-          result.errors++;
-          continue;
-        }
-        let canonicalContent;
-        let operator;
-        if (operatorAwareEnabled) {
-          const parsed = parseOperatorAwareConsolidationResponse(
-            response.content,
-            cluster
-          );
-          canonicalContent = parsed.output;
-          operator = parsed.operator;
-        } else {
-          canonicalContent = parseConsolidationResponse(response.content);
-          operator = chooseConsolidationOperator(cluster);
-        }
-        cluster.canonicalContent = canonicalContent;
-        const sorted = [...cluster.memories].sort(
-          (a, b) => new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime()
-        );
-        const newest = sorted[0];
-        const lineageIds = cluster.memories.map((m) => m.frontmatter.id);
-        const derivedFromEntries = [];
-        for (const m of cluster.memories) {
-          if (!m.path) continue;
-          const entry = await targetStorage.snapshotForProvenance(m.path);
-          if (entry) derivedFromEntries.push(entry);
-        }
-        const { id: canonicalId, tombstoneBlocked: canonicalBlocked } = await targetStorage.writeMemory(
-          newest.frontmatter.category,
-          canonicalContent,
-          {
-            actor: "semantic-consolidation",
-            confidence: newest.frontmatter.confidence,
-            tags: [
-              ...new Set(
-                cluster.memories.flatMap((m) => m.frontmatter.tags ?? [])
-              )
-            ],
-            source: "semantic-consolidation",
-            lineage: lineageIds,
-            derivedFrom: derivedFromEntries.length > 0 ? derivedFromEntries : void 0,
-            derivedVia: operator
-          }
-        );
-        if (canonicalBlocked) {
-          log.info(`[semantic-consolidation] cluster in "${cluster.category}" tombstone-blocked \u2014 keeping ${cluster.memories.length} source(s) active (pending_review ${canonicalId})`);
-          continue;
-        }
-        canonicalWriteCompleted = true;
-        result.memoriesConsolidated++;
-        for (const m of cluster.memories) {
-          const archiveResult = await targetStorage.archiveMemory(m, {
-            actor: "semantic-consolidation",
-            reasonCode: "semantic-consolidation",
-            relatedMemoryIds: [canonicalId]
-          });
-          if (archiveResult) {
-            await this.removeContentHashForMemory(
-              targetStorage,
-              m,
-              "semantic-consolidation"
-            );
-            try {
-              await this.embeddingFallback.removeFromIndex(m.frontmatter.id);
-              if (resolveIndexingCapabilities(this.config).queryAwareIndexing && m.path && m.frontmatter?.created) {
-                deindexMemory(
-                  targetStorage.dir,
-                  m.path,
-                  m.frontmatter.created,
-                  m.frontmatter.tags ?? []
-                );
-              }
-            } catch (cleanupErr) {
-              log.warn(
-                `[semantic-consolidation] index cleanup failed (non-fatal): ${cleanupErr}`
-              );
-            }
-            result.memoriesArchived++;
-          }
-        }
-        log.info(
-          `[semantic-consolidation] consolidated ${cluster.memories.length} memories \u2192 ${canonicalId}`
-        );
-      } catch (err) {
-        log.warn(
-          `[semantic-consolidation] cluster processing failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-        result.errors++;
-      } finally {
-        if (canonicalWriteCompleted) {
-        }
-      }
-    }
-    if (result.memoriesArchived > 0) {
-      await this.saveContentHashIndexes().catch(
-        (err) => log.warn(
-          `[semantic-consolidation] content-hash index save failed: ${err}`
-        )
-      );
-    }
-    log.info(
-      `[semantic-consolidation] complete: clusters=${result.clustersFound}, consolidated=${result.memoriesConsolidated}, archived=${result.memoriesArchived}, errors=${result.errors}`
-    );
-    try {
-      await materializeAfterSemanticConsolidation({
-        config: this.config,
-        memoryDir: targetStorage.dir
-      });
-    } catch (err) {
-      log.warn(
-        `[semantic-consolidation] Codex materialize post-hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (this.config.peerProfileReasonerEnabled) {
-      try {
-        const { runPeerProfileReasoner } = await import("./peers/index.js");
-        const llm2 = new FallbackLlmClient2(
-          this.config.gatewayConfig,
-          fallbackLlmRuntimeContextFromConfig(this.config)
-        );
-        const peerResult = await runPeerProfileReasoner({
-          memoryDir: targetStorage.dir,
-          enabled: true,
-          llm: llm2,
-          model: this.config.peerProfileReasonerModel,
-          minInteractions: this.config.peerProfileReasonerMinInteractions,
-          maxFieldsPerRun: this.config.peerProfileReasonerMaxFieldsPerRun,
-          log: {
-            debug: (msg) => log.debug(msg),
-            info: (msg) => log.info(msg),
-            warn: (msg) => log.warn(msg)
-          }
-        });
-        log.info(
-          `[peer-profile-reasoner] complete: peers=${peerResult.peersConsidered}, processed=${peerResult.peersProcessed}, fields=${peerResult.fieldsApplied}`
-        );
-      } catch (err) {
-        log.warn(
-          `[peer-profile-reasoner] post-consolidation hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
-        );
+      } catch (error) {
+        log.debug(`deep-sleep governance: entity synthesis refresh failed after apply: ${error}`);
       }
     }
-    return result;
+    return summarizeGovernanceResultForDreams(govResult, options?.dryRun === true);
+  }
+  // Issue #1526 (seam 5): semantic consolidation moved to
+  // SemanticConsolidationCoordinator. Thin delegation keeps all
+  // call sites (runConsolidation, runSemanticConsolidationNow,
+  // runSemanticConsolidationFanout) stable.
+  async runSemanticConsolidation(options) {
+    return this.semanticConsolidationCoordinator.runSemanticConsolidation(options);
   }
   async waitForExtractionIdle(timeoutMs = 6e4) {
     return this.extractionQueueCoordinator.waitForIdle(timeoutMs);
@@ -5255,7 +5603,7 @@ ${evidenceText}`
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path3.join(storage.dir, categoryDir, date);
+        const dateDir = path4.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -5264,7 +5612,7 @@ ${evidenceText}`
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path3.join(dateDir, entry.name);
+            const fullPath = path4.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile2(fullPath, "utf-8");
@@ -5286,7 +5634,7 @@ ${evidenceText}`
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path3.basename(entry.name, ".md"),
+                  id: fm.id || path4.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -5309,13 +5657,13 @@ ${evidenceText}`
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path3.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path4.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path3.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path4.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -5363,7 +5711,7 @@ ${evidenceText}`
       action: event.action,
       eligibility,
       options: {
-        actionsEnabled: this.config.contextCompressionActionsEnabled,
+        actionsEnabled: resolveCompressionCapabilities(this.config).contextCompressionActions,
         maxCompressionTokensPerHour: this.config.maxCompressionTokensPerHour
       }
     });
@@ -5419,7 +5767,7 @@ ${evidenceText}`
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path3.join(
+    const snapshotPath = path4.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -5458,7 +5806,7 @@ ${evidenceText}`
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path3.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path4.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -5491,7 +5839,7 @@ ${evidenceText}`
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path3.join(
+    const snapshotPath = path4.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -5644,7 +5992,7 @@ ${r.snippet.trim()}
       const entries = await readdir(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path3.join(dir, entry.name);
+        const fullPath = path4.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -5872,7 +6220,7 @@ ${r.snippet.trim()}
       options.abortSignal?.addEventListener("abort", onAbort, { once: true });
     }
     const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-    const namespacesEnabled = this.config.namespacesEnabled;
+    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
     if (namespacesEnabled && !principal) {
       throw new Error("authentication required: namespaces are enabled and no principal was supplied");
     }
@@ -6213,7 +6561,7 @@ ${r.snippet.trim()}
     const scoped = /* @__PURE__ */ new Set();
     for (const memoryPath of paths) {
       if (!memoryPath || isArtifactMemoryPath(memoryPath)) continue;
-      if (this.config.namespacesEnabled && !recallNamespaces.includes(this.namespaceFromPath(memoryPath))) {
+      if (resolveNamespaceCapabilities(this.config).namespaces && !recallNamespaces.includes(this.namespaceFromPath(memoryPath))) {
         continue;
       }
       scoped.add(memoryPath);
@@ -6296,7 +6644,7 @@ ${r.snippet.trim()}
     const tokens = Array.from(new Set(tokenizeRecallQuery(query)));
     const memories = (await Promise.all(
       Array.from(candidatePaths).map(async (memoryPath) => {
-        const namespace = this.config.namespacesEnabled ? this.namespaceFromPath(memoryPath) : this.config.defaultNamespace;
+        const namespace = resolveNamespaceCapabilities(this.config).namespaces ? this.namespaceFromPath(memoryPath) : this.config.defaultNamespace;
         const storage = await this.storageRouter.storageFor(namespace);
         return await storage.readMemoryByPath(memoryPath);
       })
@@ -6550,7 +6898,7 @@ ${r.snippet.trim()}
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path3.isAbsolute(resolvedPath)) {
+      if (!path4.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -6575,7 +6923,7 @@ ${r.snippet.trim()}
         }
         continue;
       }
-      if (path3.isAbsolute(result.path)) {
+      if (path4.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -6618,7 +6966,7 @@ ${r.snippet.trim()}
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path3.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path4.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -6634,7 +6982,7 @@ ${r.snippet.trim()}
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path3.resolve(storage.dir, candidate.path);
+        const memoryPath = path4.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (deadlineExpired()) break;
         if (!memory) continue;
@@ -6659,7 +7007,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path3.resolve(storage.dir, candidate.seed),
+          seed: path4.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -6680,12 +7028,12 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path3.join(
+      const snapshotPath = path4.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -6712,20 +7060,20 @@ ${r.snippet.trim()}
         finalResults: (options.finalResults ?? []).slice(0, 64),
         shadowComparison: options.shadowComparison
       };
-      await writeFile2(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile3(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last graph recall write failed: ${err}`);
     }
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path3.join(
+      const snapshotPath = path4.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
-      await writeFile2(
+      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
+      await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -6736,13 +7084,13 @@ ${r.snippet.trim()}
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path3.join(
+      const snapshotPath = path4.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
-      await writeFile2(
+      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
+      await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -6756,9 +7104,9 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path3.join(stateDir, "last_intent.json");
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
-      await writeFile2(
+      const snapshotPath = path4.join(stateDir, "last_intent.json");
+      await mkdir3(path4.dirname(snapshotPath), { recursive: true });
+      await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -6768,13 +7116,13 @@ ${r.snippet.trim()}
     }
   }
   async resolveStateDirForNamespace(namespace) {
-    if (!this.config.namespacesEnabled) {
-      return path3.join(this.config.memoryDir, "state");
+    if (!resolveNamespaceCapabilities(this.config).namespaces) {
+      return path4.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path3.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path4.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path3.join(
+    const candidate = path4.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -6782,11 +7130,11 @@ ${r.snippet.trim()}
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path3.join(candidate, "state");
+        return path4.join(candidate, "state");
       }
     } catch {
     }
-    return path3.join(this.config.memoryDir, "state");
+    return path4.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -6984,7 +7332,7 @@ ${r.snippet.trim()}
     }
     const timings = {};
     const profileTraceId = this.profiler.startTrace("recall", sessionKey, {
-      qmdEnabled: this.config.qmdEnabled,
+      qmdEnabled: resolveQmdCapabilities(this.config).qmd,
       rerankEnabled: caps.rerank,
       parallelRetrieval: caps.parallelRetrieval
     });
@@ -7141,7 +7489,7 @@ ${r.snippet.trim()}
       );
       const embeddingFetchLimit = computedFetchLimit;
       const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-      const namespacesEnabled = this.config.namespacesEnabled;
+      const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
       if (namespacesEnabled && !principal) {
         throw new Error("authentication required: namespaces are enabled and no principal was supplied");
       }
@@ -7188,7 +7536,7 @@ ${r.snippet.trim()}
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path3.sep).join("/");
+        const normalizedPath = resultPath.split(path4.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -7317,7 +7665,7 @@ ${r.snippet.trim()}
           retrievalQueryLength: retrievalQuery.length,
           recallMode,
           recallResultLimit,
-          qmdEnabled: this.config.qmdEnabled,
+          qmdEnabled: resolveQmdCapabilities(this.config).qmd,
           qmdAvailable: this.qmd.isAvailable(),
           recallNamespaces: [],
           source: recallSource,
@@ -7338,7 +7686,7 @@ ${r.snippet.trim()}
         profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path3.join(this.config.memoryDir, ".empty-scope-profile") },
+        { dir: path4.join(this.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -7622,7 +7970,7 @@ ${lines.join("\n\n")}`;
       const identityContinuityPromise = (async () => {
         if (!this.isRecallSectionEnabled(
           "identity-continuity",
-          this.config.identityContinuityEnabled === true
+          resolveIdentityContinuityCapabilities(this.config).identityContinuity === true
         ))
           return null;
         const t0 = Date.now();
@@ -7820,9 +8168,9 @@ ${rows.join("\n")}
       })();
       const objectiveStatePromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.objectiveStateMemoryEnabled || !this.config.objectiveStateRecallEnabled || !this.isRecallSectionEnabled(
+        if (!resolveObjectiveStateCapabilities(this.config).objectiveStateMemory || !resolveObjectiveStateCapabilities(this.config).objectiveStateRecall || !this.isRecallSectionEnabled(
           "objective-state",
-          this.config.objectiveStateRecallEnabled === true
+          resolveObjectiveStateCapabilities(this.config).objectiveStateRecall === true
         )) {
           recordRecallSectionMetric({
             section: "objectiveState",
@@ -7850,13 +8198,13 @@ ${rows.join("\n")}
         }
         const objectiveStateSearches = await Promise.all(
           recallNamespaces.map(async (namespace) => {
-            const storage = this.config.namespacesEnabled ? await this.getStorage(namespace) : null;
+            const storage = resolveNamespaceCapabilities(this.config).namespaces ? await this.getStorage(namespace) : null;
             return searchObjectiveStateSnapshots({
-              memoryDir: this.config.namespacesEnabled ? storage.dir : this.config.memoryDir,
+              memoryDir: resolveNamespaceCapabilities(this.config).namespaces ? storage.dir : this.config.memoryDir,
               objectiveStateStoreDir: objectiveStateStoreOverrideForNamespace({
                 memoryDir: this.config.memoryDir,
                 configuredStoreDir: this.config.objectiveStateStoreDir,
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 namespace
               }),
               query: retrievalQuery,
@@ -8041,9 +8389,9 @@ ${rows.join("\n")}
       })();
       const trustZonePromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.trustZonesEnabled || !this.config.trustZoneRecallEnabled || !this.isRecallSectionEnabled(
+        if (!resolveSecurityCapabilities(this.config).trustZones || !resolveSecurityCapabilities(this.config).trustZoneRecall || !this.isRecallSectionEnabled(
           "trust-zones",
-          this.config.trustZoneRecallEnabled === true
+          resolveSecurityCapabilities(this.config).trustZoneRecall === true
         )) {
           recordRecallSectionMetric({
             section: "trustZones",
@@ -8612,7 +8960,7 @@ ${rows.join("\n")}
               qmdFetchLimit,
               qmdHybridFetchLimit,
               {
-                namespacesEnabled: this.config.namespacesEnabled,
+                namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                 recallNamespaces,
                 resolveNamespace: (p) => this.namespaceFromPath(p),
                 queryAwarePrefilter,
@@ -8814,11 +9162,11 @@ ${formatted}`;
         if (!this.config.compactionResetEnabled) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path3.join(
+        const signalPath = path4.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path3.join(workspaceDir, "BOOT.md");
+        const bootPath = path4.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -8945,7 +9293,7 @@ ${formatted}`;
             workspaceDir: this.config.workspaceDir,
             memoryDir: this.config.memoryDir,
             config: this.config.nativeKnowledge,
-            recallNamespaces: this.config.namespacesEnabled ? recallNamespaces : void 0,
+            recallNamespaces: resolveNamespaceCapabilities(this.config).namespaces ? recallNamespaces : void 0,
             defaultNamespace: this.config.defaultNamespace,
             abortSignal: nativeKnowledgeAbort.signal
           }).catch(() => []);
@@ -9700,7 +10048,7 @@ ${tmtNode.summary}`
           []
         );
         let memoryResults = memoryResultsRaw;
-        if (this.config.namespacesEnabled) {
+        if (resolveNamespaceCapabilities(this.config).namespaces) {
           memoryResults = memoryResults.filter(
             (r) => recallNamespaces.includes(this.namespaceFromPath(r.path))
           );
@@ -9983,7 +10331,7 @@ ${tmtNode.summary}`
                 const scopedCandidates = filterRecallCandidates(
                   prefilteredEmbeddingResults,
                   {
-                    namespacesEnabled: this.config.namespacesEnabled,
+                    namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                     recallNamespaces,
                     resolveNamespace: (p) => this.namespaceFromPath(p),
                     limit: embeddingFetchLimit
@@ -10144,7 +10492,7 @@ ${tmtNode.summary}`
               const scopedCandidates = filterRecallCandidates(
                 prefilteredEmbeddingResults,
                 {
-                  namespacesEnabled: this.config.namespacesEnabled,
+                  namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
                   recallNamespaces,
                   resolveNamespace: (p) => this.namespaceFromPath(p),
                   limit: embeddingFetchLimit
@@ -10503,7 +10851,7 @@ ${tmtNode.summary}`
       });
       if (this.isRecallSectionEnabled(
         "compression-guidelines",
-        this.config.compressionGuidelineLearningEnabled === true
+        resolveCompressionCapabilities(this.config).compressionGuidelineLearning === true
       )) {
         const compressionGuidelineSection = await this.buildCompressionGuidelineRecallSection();
         if (compressionGuidelineSection) {
@@ -10809,7 +11157,7 @@ _Context: ${topQuestion.context}_`
         retrievalQueryLength: retrievalQuery.length,
         recallMode,
         recallResultLimit,
-        qmdEnabled: this.config.qmdEnabled,
+        qmdEnabled: resolveQmdCapabilities(this.config).qmd,
         qmdAvailable: this.qmd.isAvailable(),
         recallNamespaces,
         source: recallSource,
@@ -11982,7 +12330,7 @@ ${normalized}`).digest("hex");
     const profileAllowsSharedWrites = !scopeProfileWritePlan || Boolean(
       scopeProfileWritePlan.profile.readOrder.includes("serverShared") && scopeProfileWritePlan.readNamespaces.includes(this.config.sharedNamespace) && sharedProfileLayer?.readable && sharedProfileLayer.writable && sharedPromotionTarget?.authorized
     );
-    const namespacesEnabled = this.config.namespacesEnabled;
+    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
     const profileAutoPromotionAllows = (category, confidence) => {
       if (!scopeProfileWritePlan) return false;
       const actualTier = confidenceTier(confidence);
@@ -12010,7 +12358,7 @@ ${normalized}`).digest("hex");
       return scopeProfileWritePlan.profile.autoPromote.targets.includes("serverShared") && profileAutoPromotionAllows(category, confidence);
     };
     const shouldPromoteToShared = (targetStorage, category, confidence) => {
-      if (!this.config.namespacesEnabled || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(category, confidence))
+      if (!resolveNamespaceCapabilities(this.config).namespaces || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(category, confidence))
         return false;
       if (this.storageDirNamespace(targetStorage.dir) === this.config.sharedNamespace)
         return false;
@@ -13420,7 +13768,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path3.relative(storage.dir, m.path);
+            const rel = path4.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -13485,7 +13833,7 @@ ${normalized}`).digest("hex");
     const needsFullRebuild = !indexesExist(this.config.memoryDir);
     if (!needsFullRebuild && persistedIds.length === 0) return;
     try {
-      const allMemories = needsFullRebuild && this.config.namespacesEnabled ? await this.readAllMemoriesForNamespaces(
+      const allMemories = needsFullRebuild && resolveNamespaceCapabilities(this.config).namespaces ? await this.readAllMemoriesForNamespaces(
         Array.from(
           /* @__PURE__ */ new Set([
             this.config.defaultNamespace,
@@ -13744,7 +14092,7 @@ ${normalized}`).digest("hex");
     }
     if (this.config.semanticConsolidationEnabled) {
       try {
-        const stateFilePath = path3.join(
+        const stateFilePath = path4.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -13792,9 +14140,9 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path3.join(this.config.memoryDir, "state");
-            await mkdir2(stateDir, { recursive: true });
-            await writeFile2(
+            const stateDir = path4.join(this.config.memoryDir, "state");
+            await mkdir3(stateDir, { recursive: true });
+            await writeFile3(
               stateFilePath,
               JSON.stringify({ lastRunAt: (/* @__PURE__ */ new Date()).toISOString() }),
               "utf-8"
@@ -13919,65 +14267,6 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
   async buildCompressionGuidelineRecallSection() {
     return this.compressionGuidelineCoordinator.buildCompressionGuidelineRecallSection();
   }
-  actionOutcomePriorDelta(event) {
-    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;
-    }
-  }
-  async buildLifecycleActionPriors(storage = this.storage) {
-    const events = await storage.readMemoryActionEvents(1200);
-    if (events.length === 0) return /* @__PURE__ */ new Map();
-    const nowMs = Date.now();
-    const windowMs = 14 * 24 * 60 * 60 * 1e3;
-    const byMemory = /* @__PURE__ */ new Map();
-    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 = /* @__PURE__ */ new Map();
-    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;
-  }
   async recordScheduledDreamsPhaseRun(phase, itemsProcessed, notes, timing = {}) {
     try {
       const { recordDreamsPhaseRun } = await import("./dreams-ledger-6UODQOX6.js");
@@ -14001,223 +14290,24 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
     return { memoriesAssessed: lifecycleCorpus.length };
   }
   async runLifecyclePolicyPass(allMemories, storage = this.storage) {
-    const now = /* @__PURE__ */ new Date();
-    const nowIso = now.toISOString();
-    const countsByState = {
-      candidate: 0,
-      validated: 0,
-      active: 0,
-      stale: 0,
-      archived: 0
-    };
-    const transitionCounts = {};
-    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 = typeof actionPriorScore === "number" && Number.isFinite(actionPriorScore) ? { actionPriorScore } : void 0;
-      const decision = decideLifecycleTransition(memory, policy, now, signals);
-      const nextState = 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 === void 0 || memory.frontmatter.decayScore === void 0 || memory.frontmatter.lastValidatedAt === void 0 || 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;
-    }
-    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 = path3.join(
-      storage.dir,
-      "state",
-      "lifecycle-metrics.json"
-    );
-    await mkdir2(path3.dirname(metricsPath), { recursive: true });
-    await writeFile2(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.
-   */
   async runFactArchival(allMemories) {
-    const now = Date.now();
-    const ageCutoffMs = this.config.factArchivalAgeDays * 24 * 60 * 60 * 1e3;
-    const protectedCategories = new Set(
-      this.config.factArchivalProtectedCategories
-    );
-    let archivedCount = 0;
-    for (const memory of allMemories) {
-      const fm = memory.frontmatter;
-      if (fm.status && fm.status !== "active") continue;
-      if (protectedCategories.has(fm.category)) continue;
-      if (fm.category === "correction") continue;
-      const createdMs = new Date(fm.created).getTime();
-      if (now - createdMs < ageCutoffMs) continue;
-      const importanceScore = fm.importance?.score ?? 0.5;
-      if (importanceScore >= this.config.factArchivalMaxImportance) continue;
-      const accessCount = fm.accessCount ?? 0;
-      if (accessCount > this.config.factArchivalMaxAccessCount) continue;
-      const result = await this.storage.archiveMemory(memory);
-      if (result) {
-        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++;
-      }
-    }
-    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).
-   */
   async runSummarization(allMemories) {
-    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}) \u2014 running summarization`
-    );
-    const sorted = activeMemories.sort(
-      (a, b) => new Date(a.frontmatter.created).getTime() - new Date(b.frontmatter.created).getTime()
-    );
-    const recentToKeep = Math.max(0, this.config.summarizationRecentToKeep);
-    const toSummarize = recentToKeep > 0 ? sorted.slice(0, -recentToKeep) : sorted;
-    const candidates = toSummarize.filter((m) => {
-      if (m.frontmatter.entityRef) return false;
-      const protectedTags = this.config.summarizationProtectedTags;
-      if (m.frontmatter.tags.some((t) => protectedTags.includes(t)))
-        return false;
-      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 \u2014 skipping`
-      );
-      return;
-    }
-    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;
-      const summary = {
-        id: `summary-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-        createdAt: (/* @__PURE__ */ 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);
-      const archived = await this.storage.archiveMemories(
-        batch.map((m) => m.frontmatter.id),
-        summary.id
-      );
-      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).
-   */
   async runTopicExtraction(allMemories) {
-    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 */
   static IDENTITY_CONSOLIDATE_THRESHOLD = 8e3;
   async autoConsolidateIdentity() {
-    const namespaces = this.config.namespacesEnabled ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? await this.maintenanceNamespaces() : [this.config.defaultNamespace];
     for (const namespace of namespaces) {
       const storage = await this.storageRouter.storageFor(namespace);
-      const identityNamespace = this.config.namespacesEnabled && namespace !== this.config.defaultNamespace ? namespace : void 0;
+      const identityNamespace = resolveNamespaceCapabilities(this.config).namespaces && namespace !== this.config.defaultNamespace ? namespace : void 0;
       const reflectionsContent = await storage.readIdentityReflections() ?? "";
       const existingIdentity = await storage.readIdentity(
         this.config.workspaceDir,
@@ -14486,7 +14576,7 @@ ${lines.join("\n\n")}`;
     return { text: `${content.slice(0, headroom)}${suffix}`, truncated: true };
   }
   async buildIdentityContinuitySection(options) {
-    if (!this.config.identityContinuityEnabled) return null;
+    if (!resolveIdentityContinuityCapabilities(this.config).identityContinuity) return null;
     if (this.config.identityMaxInjectChars <= 0) return null;
     const resolved = resolveEffectiveIdentityInjectionMode({
       configuredMode: this.config.identityInjectionMode,
@@ -14557,7 +14647,7 @@ ${lines.join("\n\n")}`;
     }
   }
   queueEvalShadowRecall(record) {
-    if (!this.config.evalHarnessEnabled || !this.config.evalShadowModeEnabled)
+    if (!resolveEvalCapabilities(this.config).evalHarness || !resolveEvalCapabilities(this.config).evalShadowMode)
       return;
     this.evalShadowWriteChain = this.evalShadowWriteChain.catch(() => void 0).then(async () => {
       try {
@@ -14619,13 +14709,13 @@ ${lines.join("\n\n")}`;
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirFor(storage);
-        const storageKey = storageDir ? path3.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path4.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
       };
       const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : this.config.defaultNamespace;
-      if (recallNamespaces.length === 0 || !this.config.namespacesEnabled || recallNamespaces.includes(fallbackNamespace)) {
+      if (recallNamespaces.length === 0 || !resolveNamespaceCapabilities(this.config).namespaces || recallNamespaces.includes(fallbackNamespace)) {
         addStorage(fallbackStorage);
       }
       if (recallNamespaces.length > 0) {
@@ -14649,7 +14739,7 @@ ${lines.join("\n\n")}`;
           continue;
         }
         try {
-          const coldRoot = path3.join(storageDir, "cold");
+          const coldRoot = path4.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(
             coldRoot,
             parts.relativePath
@@ -14690,7 +14780,7 @@ ${lines.join("\n\n")}`;
         return null;
       }
     }
-    if (path3.isAbsolute(resultPath)) {
+    if (path4.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -14729,14 +14819,14 @@ ${lines.join("\n\n")}`;
     );
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path3.isAbsolute(memory.path)) {
+    if (path4.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(
         memory.path,
         fallbackStorage,
         recallNamespaces
       );
       ownerNamespace = ownerStorage?.namespace ?? null;
-      if (!ownerNamespace && this.config.namespacesEnabled) return null;
+      if (!ownerNamespace && resolveNamespaceCapabilities(this.config).namespaces) return null;
     }
     ownerNamespace ??= this.namespaceFromPath(memory.path);
     if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
@@ -14753,16 +14843,16 @@ ${lines.join("\n\n")}`;
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path3.resolve(resultPath);
-    const memoryRoot = path3.resolve(this.config.memoryDir);
-    const namespacesRoot = path3.join(memoryRoot, "namespaces");
+    const resolvedPath = path4.resolve(resultPath);
+    const memoryRoot = path4.resolve(this.config.memoryDir);
+    const namespacesRoot = path4.join(memoryRoot, "namespaces");
     const fallbackStorageDir = typeof fallbackStorage.dir === "string" && fallbackStorage.dir ? fallbackStorage.dir : null;
     const matches = [];
     const seenDirs = /* @__PURE__ */ new Set();
     const maybeAddStorage = (storage, namespace) => {
       const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
       if (!storageDir) return;
-      const candidateRoot = path3.resolve(storageDir);
+      const candidateRoot = path4.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -14780,7 +14870,7 @@ ${lines.join("\n\n")}`;
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path3.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path4.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(
@@ -14825,7 +14915,7 @@ ${lines.join("\n\n")}`;
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path4, c] of nsMap) counters.set(path4, c);
+        for (const [path5, c] of nsMap) counters.set(path5, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -14908,7 +14998,7 @@ ${lines.join("\n\n")}`;
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path4) => {
+        readMemoryFrontmatter: async (path5) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -14919,7 +15009,7 @@ ${lines.join("\n\n")}`;
             }
           }
           if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path4, fallbackReader, namespaces);
+          const memory = await this.readQmdResultMemory(path5, fallbackReader, namespaces);
           return memory ? memory.frontmatter : null;
         }
       },
@@ -15088,13 +15178,13 @@ ${lines.join("\n\n")}`;
    *     so facts from non-default namespaces can't cross-match.
    */
   semanticDedupScopeFor(targetStorage) {
-    if (!this.config.namespacesEnabled) return {};
-    const memoryDir = path3.resolve(this.config.memoryDir);
-    const storageDir = path3.resolve(targetStorage.dir);
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
+    const memoryDir = path4.resolve(this.config.memoryDir);
+    const storageDir = path4.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path3.relative(memoryDir, storageDir);
+    let rel = path4.relative(memoryDir, storageDir);
     if (!rel || rel.startsWith("..")) {
       log.debug(
         `semantic dedup: target storage dir ${storageDir} is outside memoryDir ${memoryDir}; scoping lookup to absolute path prefix`
@@ -15113,7 +15203,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path3.isAbsolute(hit.path) ? hit.path : path3.join(this.config.memoryDir, hit.path);
+      const fullPath = path4.isAbsolute(hit.path) ? hit.path : path4.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -15221,7 +15311,7 @@ ${lines.join("\n\n")}`;
         if (timeoutHandle) clearTimeout(timeoutHandle);
       }
     };
-    const coldQmdEnabled = this.config.qmdColdTierEnabled === true;
+    const coldQmdEnabled = resolveQmdCapabilities(this.config).qmdColdTier === true;
     const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
     const coldMaxResults = this.config.qmdColdMaxResults ?? this.config.qmdMaxResults;
     let longTerm = [];
@@ -15256,7 +15346,7 @@ ${lines.join("\n\n")}`;
             coldFetchLimit,
             coldHybridLimit,
             {
-              namespacesEnabled: this.config.namespacesEnabled,
+              namespacesEnabled: resolveNamespaceCapabilities(this.config).namespaces,
               recallNamespaces: options.recallNamespaces,
               resolveNamespace: (p) => this.namespaceFromPath(p),
               collection: coldCollection,
@@ -15302,7 +15392,7 @@ ${lines.join("\n\n")}`;
     }
     if (longTerm.length === 0) return [];
     let results = longTerm;
-    if (this.config.namespacesEnabled) {
+    if (resolveNamespaceCapabilities(this.config).namespaces) {
       const recallRoots = [];
       const seenRecallRoots = /* @__PURE__ */ new Set();
       for (const namespace of options.recallNamespaces) {
@@ -15310,7 +15400,7 @@ ${lines.join("\n\n")}`;
           const storage = await this.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path3.resolve(storageDir);
+          const recallRoot = path4.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -15334,8 +15424,8 @@ ${lines.join("\n\n")}`;
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path3.isAbsolute(result.path)) {
-          const resolvedPath = path3.resolve(result.path);
+        if (path4.isAbsolute(result.path)) {
+          const resolvedPath = path4.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -15351,8 +15441,8 @@ ${lines.join("\n\n")}`;
     }
     results = results.filter((r) => !isArtifactMemoryPath(r.path));
     if (results.length === 0) return [];
-    const isFullModeGraphAssist = this.config.qmdTierParityGraphEnabled && graphCaps.multiGraphMemory && caps.graphAssistInFullMode && options.recallMode === "full" && results.length >= Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
-    const shouldRunGraphExpansion = this.config.qmdTierParityGraphEnabled && (options.recallMode === "graph_mode" || isFullModeGraphAssist);
+    const isFullModeGraphAssist = resolveQmdCapabilities(this.config).qmdTierParityGraph && graphCaps.multiGraphMemory && caps.graphAssistInFullMode && options.recallMode === "full" && results.length >= Math.max(1, this.config.graphAssistMinSeedResults ?? 3);
+    const shouldRunGraphExpansion = resolveQmdCapabilities(this.config).qmdTierParityGraph && (options.recallMode === "graph_mode" || isFullModeGraphAssist);
     if (shouldRunGraphExpansion) {
       const { merged } = await this.expandResultsViaGraph({
         memoryResults: results,
@@ -15513,7 +15603,7 @@ ${lines.join("\n\n")}`;
   async flushAccessTracking() {
     if (this.accessTrackingBuffer.size === 0) return;
     const entries = [];
-    const namespaces = this.config.namespacesEnabled ? Array.from(
+    const namespaces = resolveNamespaceCapabilities(this.config).namespaces ? Array.from(
       /* @__PURE__ */ new Set([
         this.config.defaultNamespace,
         this.config.sharedNamespace,
@@ -16169,7 +16259,7 @@ ${lines.join("\n\n")}`;
     return resolved;
   }
   namespaceFromPath(p) {
-    if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
+    if (!resolveNamespaceCapabilities(this.config).namespaces) return this.config.defaultNamespace;
     const parts = qmdCollectionPathParts(p);
     const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
     if (collectionNamespace) return collectionNamespace;
@@ -16270,4 +16360,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-OUITHS6V.js.map
+//# sourceMappingURL=chunk-FLCYY5JX.js.map