@remnic/core 9.3.734 → 9.3.736

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

@@ -7,10 +7,10 @@ import {
 } from "./chunk-OZECYVGI.js";
 import {
   CompressionGuidelineCoordinator
-} from "./chunk-SYX73XD7.js";
+} from "./chunk-IXGXALRV.js";
 import {
   MaintenanceScheduler
-} from "./chunk-5OYHJIJN.js";
+} from "./chunk-GYICIICQ.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -29,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-ET5HXSQL.js";
+} from "./chunk-IPI45Q4S.js";
 import {
   SharedContextManager
 } from "./chunk-UFS7OXGL.js";
@@ -63,7 +63,7 @@ import {
 } from "./chunk-UHGBNIOS.js";
 import {
   HourlySummarizer
-} from "./chunk-PEF2XOIV.js";
+} from "./chunk-HFXZIF3V.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -160,7 +160,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-WTTVFSCO.js";
+} from "./chunk-FF36YNKY.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -169,7 +169,7 @@ import {
 } from "./chunk-PWFWCGOO.js";
 import {
   LocalLlmClient
-} from "./chunk-2L5RTVMO.js";
+} from "./chunk-IX4L7E5G.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -193,12 +193,12 @@ import {
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-UH3NYOHN.js";
+} from "./chunk-CHJIWG2H.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-V5OVSGB6.js";
+} from "./chunk-AESC5OQJ.js";
 import {
   RoutingRulesStore
 } from "./chunk-WIWPSQYU.js";
@@ -228,14 +228,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-FAGERSH2.js";
+} from "./chunk-AE7NTZ75.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-7FPJFCXL.js";
+} from "./chunk-BXPG5AVX.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-54RCE5Z3.js";
+} from "./chunk-NNJKEAP2.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -333,14 +333,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-UK6U5C3N.js";
+} from "./chunk-GB2FZOWB.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-3QETM5NG.js";
+} from "./chunk-ZBZ4XULO.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-K7PAILHO.js";
+} from "./chunk-5BOQNB2K.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -363,7 +363,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-CILX2XW7.js";
+} from "./chunk-NDKW67ER.js";
 import {
   searchCausalTrajectories
 } from "./chunk-SQNED75R.js";
@@ -465,18 +465,23 @@ import {
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-LV32K4OP.js";
+} from "./chunk-OYHYBHHI.js";
 import {
   resolveCapabilities,
+  resolveCompressionCapabilities,
   resolveCreationMemoryCapabilities,
+  resolveEvalCapabilities,
   resolveGraphConstructionCapabilities,
   resolveIdentityContinuityCapabilities,
   resolveIndexingCapabilities,
   resolveLocalLlmCapabilities,
   resolveMemoryLifecycleCapabilities,
   resolveNamespaceCapabilities,
-  resolveQmdCapabilities
-} from "./chunk-SHJGBAIW.js";
+  resolveObjectiveStateCapabilities,
+  resolveQmdCapabilities,
+  resolveSecurityCapabilities,
+  resolveUtilityLearningCapabilities
+} from "./chunk-JWDE7OVJ.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule
@@ -501,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 { createHash as createHash2, 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
@@ -1065,68 +1070,559 @@ var SemanticConsolidationCoordinator = class {
             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) {
+        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`
+    );
+  }
+};
+
+// src/orchestration/entity-synthesis-coordinator.ts
+import { createHash } from "crypto";
+function dedupeEntitySynthesisEvidenceEntries(entries) {
+  const dedupedEvidenceEntries = [];
+  const evidenceByFact = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const normalizedFact = entry.text.trim();
+    if (!normalizedFact) continue;
+    const existing = evidenceByFact.get(normalizedFact);
+    if (!existing) {
+      evidenceByFact.set(normalizedFact, { newest: entry, oldest: entry });
+      continue;
+    }
+    if (compareEntityTimestamps(entry.timestamp, existing.newest.timestamp) > 0) {
+      existing.newest = entry;
+    }
+    if (compareEntityTimestamps(entry.timestamp, existing.oldest.timestamp) < 0) {
+      existing.oldest = entry;
+    }
+  }
+  for (const { newest, oldest } of evidenceByFact.values()) {
+    dedupedEvidenceEntries.push(newest);
+    const newestKey = [
+      newest.timestamp,
+      newest.source ?? "",
+      newest.sessionKey ?? "",
+      newest.principal ?? "",
+      newest.text
+    ].join("\0");
+    const oldestKey = [
+      oldest.timestamp,
+      oldest.source ?? "",
+      oldest.sessionKey ?? "",
+      oldest.principal ?? "",
+      oldest.text
+    ].join("\0");
+    if (oldestKey !== newestKey) {
+      dedupedEvidenceEntries.push(oldest);
+    }
+  }
+  return dedupedEvidenceEntries;
+}
+function flattenStructuredSectionEvidence(sections) {
+  return (sections ?? []).flatMap(
+    (section) => section.facts.map((fact) => fact.trim()).filter((fact) => fact.length > 0).map((fact) => ({
+      timestamp: "",
+      text: fact,
+      source: `section:${section.title}`
+    }))
+  );
+}
+function fingerprintEntitySynthesisEvidence(entity) {
+  const fingerprint = createHash("sha256");
+  const timelineEntries = entity.timeline.map((entry) => [
+    entry.timestamp,
+    entry.source ?? "",
+    entry.sessionKey ?? "",
+    entry.principal ?? "",
+    entry.text
+  ].join("\0")).sort();
+  const timelineEntrySeparator = String.fromCharCode(1);
+  const structuredFactsSeparator = String.fromCharCode(2);
+  fingerprint.update(timelineEntries.join(timelineEntrySeparator));
+  fingerprint.update(structuredFactsSeparator);
+  fingerprint.update(fingerprintEntityStructuredFacts(entity) ?? "");
+  return fingerprint.digest("hex");
+}
+var EntitySynthesisCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  /**
+   * Process up to `maxEntities` entities from the synthesis queue for the
+   * given namespace. Returns the number of entities whose synthesis was
+   * successfully refreshed.
+   */
+  async processQueue(namespace, maxEntities = 5) {
+    const { config } = this.deps;
+    if (!config.entitySummaryEnabled || maxEntities <= 0 || config.entitySynthesisMaxTokens <= 0) return 0;
+    const storage = await this.deps.getStorage(namespace);
+    const queued = await storage.refreshEntitySynthesisQueue();
+    let processed = 0;
+    let attempted = 0;
+    for (const entityName of queued) {
+      if (attempted >= maxEntities) break;
+      attempted += 1;
+      try {
+        const raw = await storage.readEntity(entityName);
+        if (!raw) continue;
+        const entity = parseEntityFile(raw, config.entitySchemas);
+        const previousSynthesis = entity.synthesis || entity.summary || "";
+        const sortedTimelineEntries = entity.timeline.slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
+        const newerTimelineEntries = sortedTimelineEntries.filter(
+          (entry) => !entity.synthesisUpdatedAt || compareEntityTimestamps(entry.timestamp, entity.synthesisUpdatedAt) > 0
+        );
+        const appendedTimelineEntries = entity.synthesisTimelineCount === void 0 ? [] : entity.timeline.slice(Math.max(0, entity.synthesisTimelineCount));
+        const structuredEvidenceEntries = flattenStructuredSectionEvidence(entity.structuredSections);
+        const structuredEvidenceCount = structuredEvidenceEntries.length;
+        const structuredEvidenceDigest = fingerprintEntityStructuredFacts(entity);
+        const structuredEvidenceDrifted = structuredEvidenceDigest !== (entity.synthesisStructuredFactDigest?.trim() || void 0);
+        const appendedStructuredEvidenceEntries = entity.synthesisStructuredFactCount === void 0 || structuredEvidenceDrifted ? structuredEvidenceEntries : structuredEvidenceEntries.slice(Math.max(0, entity.synthesisStructuredFactCount));
+        const candidateEvidenceEntries = [
+          ...newerTimelineEntries,
+          ...appendedTimelineEntries,
+          ...appendedStructuredEvidenceEntries
+        ].slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
+        const dedupedEvidenceEntries = dedupeEntitySynthesisEvidenceEntries(
+          candidateEvidenceEntries.length > 0 ? candidateEvidenceEntries : [...sortedTimelineEntries, ...structuredEvidenceEntries]
+        );
+        const chronologicalEvidenceEntries = dedupedEvidenceEntries.slice().sort((left, right) => compareEntityTimestamps(left.timestamp, right.timestamp));
+        if (chronologicalEvidenceEntries.length === 0) continue;
+        const latestEvidenceTimestamp = chronologicalEvidenceEntries.slice().reverse().map((entry) => entry.timestamp?.trim() || void 0).find((timestamp) => Boolean(timestamp));
+        const previousSynthesisUpdatedAt = entity.synthesisUpdatedAt?.trim() || void 0;
+        const nextSynthesisUpdatedAt = compareEntityTimestamps(
+          latestEvidenceTimestamp,
+          previousSynthesisUpdatedAt
+        ) >= 0 ? latestEvidenceTimestamp : previousSynthesisUpdatedAt;
+        const evidenceBatches = [];
+        for (let index = 0; index < chronologicalEvidenceEntries.length; index += 8) {
+          evidenceBatches.push(chronologicalEvidenceEntries.slice(index, index + 8));
+        }
+        let nextSynthesis = previousSynthesis;
+        let batchFailed = false;
+        for (const evidenceEntries of evidenceBatches) {
+          const evidenceText = evidenceEntries.map((entry) => {
+            const sectionTitle = entry.source?.startsWith("section:") ? entry.source.slice("section:".length) : "";
+            const metadata = [
+              `timestamp=${entry.timestamp}`,
+              sectionTitle ? `section=${sectionTitle}` : entry.source ? `source=${entry.source}` : "",
+              entry.sessionKey ? `session=${entry.sessionKey}` : "",
+              entry.principal ? `principal=${entry.principal}` : ""
+            ].filter(Boolean).join(", ");
+            return `- ${metadata}: ${entry.text}`;
+          }).join("\n");
+          const response = await this.deps.fastChatCompletion(
+            [
+              {
+                role: "system",
+                content: "Rewrite the entity synthesis as compact current truth. Preserve uncertainty when evidence conflicts. Return plain text only."
+              },
+              {
+                role: "user",
+                content: [
+                  `Entity: ${entity.name} (${entity.type})`,
+                  nextSynthesis ? `Previous synthesis:
+${nextSynthesis}` : "Previous synthesis: none",
+                  `New evidence:
+${evidenceText}`
+                ].join("\n\n")
+              }
+            ],
+            {
+              temperature: 0.2,
+              maxTokens: config.entitySynthesisMaxTokens,
+              operation: "entity_summary",
+              priority: "background"
+            }
+          );
+          const synthesis = response?.content?.trim().replace(/^["']|["']$/g, "");
+          const maxSynthesisChars = Math.max(2e3, config.entitySynthesisMaxTokens * 8);
+          if (!synthesis || synthesis.length < 10 || synthesis.length > maxSynthesisChars) {
+            batchFailed = true;
+            break;
+          }
+          nextSynthesis = synthesis;
+        }
+        if (batchFailed || nextSynthesis.length === 0) continue;
+        const latestRaw = await storage.readEntity(entityName);
+        if (!latestRaw) continue;
+        const latestEntity = parseEntityFile(latestRaw, config.entitySchemas);
+        if (fingerprintEntitySynthesisEvidence(latestEntity) !== fingerprintEntitySynthesisEvidence(entity)) {
+          continue;
         }
-      }
-    }
-    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)
-          }
+        await storage.updateEntitySynthesis(entityName, nextSynthesis, {
+          entityUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          synthesisStructuredFactDigest: structuredEvidenceDigest,
+          synthesisStructuredFactCount: structuredEvidenceCount,
+          synthesisTimelineCount: entity.timeline.length,
+          updatedAt: nextSynthesisUpdatedAt
         });
-        log.info(
-          `[peer-profile-reasoner] complete: peers=${peerResult.peersConsidered}, processed=${peerResult.peersProcessed}, fields=${peerResult.fieldsApplied}`
-        );
+        processed += 1;
       } catch (err) {
-        log.warn(
-          `[peer-profile-reasoner] post-consolidation hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
-        );
+        log.debug(`entity synthesis refresh failed for ${entityName}: ${err}`);
       }
     }
-    return result;
+    return processed;
   }
 };
 
@@ -1462,8 +1958,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;
@@ -1561,7 +2057,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");
@@ -1611,16 +2107,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
@@ -2486,71 +2982,6 @@ var BulkImportBatchPartialFailureError = class extends Error {
     this.originalError = originalError;
   }
 };
-function dedupeEntitySynthesisEvidenceEntries(entries) {
-  const dedupedEvidenceEntries = [];
-  const evidenceByFact = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const normalizedFact = entry.text.trim();
-    if (!normalizedFact) continue;
-    const existing = evidenceByFact.get(normalizedFact);
-    if (!existing) {
-      evidenceByFact.set(normalizedFact, { newest: entry, oldest: entry });
-      continue;
-    }
-    if (compareEntityTimestamps(entry.timestamp, existing.newest.timestamp) > 0) {
-      existing.newest = entry;
-    }
-    if (compareEntityTimestamps(entry.timestamp, existing.oldest.timestamp) < 0) {
-      existing.oldest = entry;
-    }
-  }
-  for (const { newest, oldest } of evidenceByFact.values()) {
-    dedupedEvidenceEntries.push(newest);
-    const newestKey = [
-      newest.timestamp,
-      newest.source ?? "",
-      newest.sessionKey ?? "",
-      newest.principal ?? "",
-      newest.text
-    ].join("\0");
-    const oldestKey = [
-      oldest.timestamp,
-      oldest.source ?? "",
-      oldest.sessionKey ?? "",
-      oldest.principal ?? "",
-      oldest.text
-    ].join("\0");
-    if (oldestKey !== newestKey) {
-      dedupedEvidenceEntries.push(oldest);
-    }
-  }
-  return dedupedEvidenceEntries;
-}
-function flattenStructuredSectionEvidence(sections) {
-  return (sections ?? []).flatMap(
-    (section) => section.facts.map((fact) => fact.trim()).filter((fact) => fact.length > 0).map((fact) => ({
-      timestamp: "",
-      text: fact,
-      source: `section:${section.title}`
-    }))
-  );
-}
-function fingerprintEntitySynthesisEvidence(entity) {
-  const fingerprint = createHash("sha256");
-  const timelineEntries = entity.timeline.map((entry) => [
-    entry.timestamp,
-    entry.source ?? "",
-    entry.sessionKey ?? "",
-    entry.principal ?? "",
-    entry.text
-  ].join("\0")).sort();
-  const timelineEntrySeparator = String.fromCharCode(1);
-  const structuredFactsSeparator = String.fromCharCode(2);
-  fingerprint.update(timelineEntries.join(timelineEntrySeparator));
-  fingerprint.update(structuredFactsSeparator);
-  fingerprint.update(fingerprintEntityStructuredFacts(entity) ?? "");
-  return fingerprint.digest("hex");
-}
 function mapRecallSourceToXrayServedBy(source) {
   switch (source) {
     case "recent_scan":
@@ -2586,7 +3017,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;
@@ -2599,9 +3030,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);
     }
@@ -2609,12 +3040,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);
@@ -2731,11 +3162,11 @@ 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, "_");
-  const hash = createHash("sha256").update(sessionKey).digest("hex").slice(0, 12);
+  const hash = createHash2("sha256").update(sessionKey).digest("hex").slice(0, 12);
   return `${readable}-${hash}`;
 }
 function latestSourceValidAtFromTurns(turns) {
@@ -3024,11 +3455,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;
@@ -3173,7 +3604,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;
 }
@@ -3181,7 +3612,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,
@@ -3201,16 +3632,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;
@@ -3290,6 +3721,8 @@ var Orchestrator = class _Orchestrator {
   tierMigrationCoordinator;
   compressionGuidelineCoordinator;
   semanticConsolidationCoordinator;
+  lifecyclePolicyCoordinator;
+  entitySynthesisCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -3671,7 +4104,7 @@ var Orchestrator = class _Orchestrator {
     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();
@@ -3682,21 +4115,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;
@@ -3724,7 +4157,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 {
@@ -3761,7 +4194,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,
@@ -4025,7 +4458,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);
@@ -4094,7 +4527,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"
@@ -4120,6 +4553,11 @@ var Orchestrator = class _Orchestrator {
       getStorage: () => this.storage,
       fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options)
     });
+    this.entitySynthesisCoordinator = new EntitySynthesisCoordinator({
+      config,
+      getStorage: (namespace) => this.getStorage(namespace),
+      fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options)
+    });
     this.sessionObserver = new SessionObserverState({
       memoryDir: config.memoryDir,
       debounceMs: config.sessionObserverDebounceMs ?? 12e4,
@@ -4174,8 +4612,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);
@@ -4255,7 +4702,7 @@ var Orchestrator = class _Orchestrator {
       utilityPromoteThresholdDelta: this.utilityRuntimeValues?.promoteThresholdDelta ?? 0,
       utilityDemoteThresholdDelta: this.utilityRuntimeValues?.demoteThresholdDelta ?? 0
     };
-    return createHash("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
+    return createHash2("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
   }
   effectiveLifecycleThresholds() {
     const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
@@ -4466,8 +4913,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();
@@ -4498,7 +4945,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(() => {
@@ -4693,7 +5140,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-W4U6XDKI.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-2RQYDIZ7.js");
         const result = await runFirstStartMigration({
           storage: this.storage,
           config: this.config,
@@ -5007,15 +5454,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,
@@ -5023,7 +5470,7 @@ ${doc.content}` : doc.content,
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile2(abs, newContent, "utf-8");
+            await writeFile3(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -5040,8 +5487,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 = `
 
@@ -5054,7 +5501,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");
       }
     }
   }
@@ -5119,120 +5566,13 @@ ${doc.content}` : doc.content,
     }
     return true;
   }
-  async getStorage(namespace) {
-    const ns = namespace && namespace.length > 0 ? namespace : this.config.defaultNamespace;
-    return this.storageRouter.storageFor(ns);
-  }
-  async processEntitySynthesisQueue(namespace, maxEntities = 5) {
-    if (!this.config.entitySummaryEnabled || maxEntities <= 0 || this.config.entitySynthesisMaxTokens <= 0) return 0;
-    const storage = await this.getStorage(namespace);
-    const queued = await storage.refreshEntitySynthesisQueue();
-    let processed = 0;
-    let attempted = 0;
-    for (const entityName of queued) {
-      if (attempted >= maxEntities) break;
-      attempted += 1;
-      try {
-        const raw = await storage.readEntity(entityName);
-        if (!raw) continue;
-        const entity = parseEntityFile(raw, this.config.entitySchemas);
-        const previousSynthesis = entity.synthesis || entity.summary || "";
-        const sortedTimelineEntries = entity.timeline.slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
-        const newerTimelineEntries = sortedTimelineEntries.filter(
-          (entry) => !entity.synthesisUpdatedAt || compareEntityTimestamps(entry.timestamp, entity.synthesisUpdatedAt) > 0
-        );
-        const appendedTimelineEntries = entity.synthesisTimelineCount === void 0 ? [] : entity.timeline.slice(Math.max(0, entity.synthesisTimelineCount));
-        const structuredEvidenceEntries = flattenStructuredSectionEvidence(entity.structuredSections);
-        const structuredEvidenceCount = structuredEvidenceEntries.length;
-        const structuredEvidenceDigest = fingerprintEntityStructuredFacts(entity);
-        const structuredEvidenceDrifted = structuredEvidenceDigest !== (entity.synthesisStructuredFactDigest?.trim() || void 0);
-        const appendedStructuredEvidenceEntries = entity.synthesisStructuredFactCount === void 0 || structuredEvidenceDrifted ? structuredEvidenceEntries : structuredEvidenceEntries.slice(Math.max(0, entity.synthesisStructuredFactCount));
-        const candidateEvidenceEntries = [
-          ...newerTimelineEntries,
-          ...appendedTimelineEntries,
-          ...appendedStructuredEvidenceEntries
-        ].slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
-        const dedupedEvidenceEntries = dedupeEntitySynthesisEvidenceEntries(
-          candidateEvidenceEntries.length > 0 ? candidateEvidenceEntries : [...sortedTimelineEntries, ...structuredEvidenceEntries]
-        );
-        const chronologicalEvidenceEntries = dedupedEvidenceEntries.slice().sort((left, right) => compareEntityTimestamps(left.timestamp, right.timestamp));
-        if (chronologicalEvidenceEntries.length === 0) continue;
-        const latestEvidenceTimestamp = chronologicalEvidenceEntries.slice().reverse().map((entry) => entry.timestamp?.trim() || void 0).find((timestamp) => Boolean(timestamp));
-        const previousSynthesisUpdatedAt = entity.synthesisUpdatedAt?.trim() || void 0;
-        const nextSynthesisUpdatedAt = compareEntityTimestamps(
-          latestEvidenceTimestamp,
-          previousSynthesisUpdatedAt
-        ) >= 0 ? latestEvidenceTimestamp : previousSynthesisUpdatedAt;
-        const evidenceBatches = [];
-        for (let index = 0; index < chronologicalEvidenceEntries.length; index += 8) {
-          evidenceBatches.push(chronologicalEvidenceEntries.slice(index, index + 8));
-        }
-        let nextSynthesis = previousSynthesis;
-        let batchFailed = false;
-        for (const evidenceEntries of evidenceBatches) {
-          const evidenceText = evidenceEntries.map((entry) => {
-            const sectionTitle = entry.source?.startsWith("section:") ? entry.source.slice("section:".length) : "";
-            const metadata = [
-              `timestamp=${entry.timestamp}`,
-              sectionTitle ? `section=${sectionTitle}` : entry.source ? `source=${entry.source}` : "",
-              entry.sessionKey ? `session=${entry.sessionKey}` : "",
-              entry.principal ? `principal=${entry.principal}` : ""
-            ].filter(Boolean).join(", ");
-            return `- ${metadata}: ${entry.text}`;
-          }).join("\n");
-          const response = await this.fastChatCompletion(
-            [
-              {
-                role: "system",
-                content: "Rewrite the entity synthesis as compact current truth. Preserve uncertainty when evidence conflicts. Return plain text only."
-              },
-              {
-                role: "user",
-                content: [
-                  `Entity: ${entity.name} (${entity.type})`,
-                  nextSynthesis ? `Previous synthesis:
-${nextSynthesis}` : "Previous synthesis: none",
-                  `New evidence:
-${evidenceText}`
-                ].join("\n\n")
-              }
-            ],
-            {
-              temperature: 0.2,
-              maxTokens: this.config.entitySynthesisMaxTokens,
-              operation: "entity_summary",
-              priority: "background"
-            }
-          );
-          const synthesis = response?.content?.trim().replace(/^["']|["']$/g, "");
-          const maxSynthesisChars = Math.max(2e3, this.config.entitySynthesisMaxTokens * 8);
-          if (!synthesis || synthesis.length < 10 || synthesis.length > maxSynthesisChars) {
-            batchFailed = true;
-            break;
-          }
-          nextSynthesis = synthesis;
-        }
-        if (batchFailed || nextSynthesis.length === 0) continue;
-        const latestRaw = await storage.readEntity(entityName);
-        if (!latestRaw) continue;
-        const latestEntity = parseEntityFile(latestRaw, this.config.entitySchemas);
-        if (fingerprintEntitySynthesisEvidence(latestEntity) !== fingerprintEntitySynthesisEvidence(entity)) {
-          continue;
-        }
-        await storage.updateEntitySynthesis(entityName, nextSynthesis, {
-          entityUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          synthesisStructuredFactDigest: structuredEvidenceDigest,
-          synthesisStructuredFactCount: structuredEvidenceCount,
-          synthesisTimelineCount: entity.timeline.length,
-          updatedAt: nextSynthesisUpdatedAt
-        });
-        processed += 1;
-      } catch (err) {
-        log.debug(`entity synthesis refresh failed for ${entityName}: ${err}`);
-      }
-    }
-    return processed;
-  }
+  async getStorage(namespace) {
+    const ns = namespace && namespace.length > 0 ? namespace : this.config.defaultNamespace;
+    return this.storageRouter.storageFor(ns);
+  }
+  async processEntitySynthesisQueue(namespace, maxEntities = 5) {
+    return this.entitySynthesisCoordinator.processQueue(namespace, maxEntities);
+  }
   async generateDaySummary(memories) {
     if (this.initPromise) {
       let initGateTimeoutHandle;
@@ -5287,7 +5627,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;
@@ -5296,7 +5636,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");
@@ -5318,7 +5658,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,
@@ -5341,13 +5681,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(
@@ -5395,7 +5735,7 @@ ${evidenceText}`
       action: event.action,
       eligibility,
       options: {
-        actionsEnabled: this.config.contextCompressionActionsEnabled,
+        actionsEnabled: resolveCompressionCapabilities(this.config).contextCompressionActions,
         maxCompressionTokensPerHour: this.config.maxCompressionTokensPerHour
       }
     });
@@ -5451,7 +5791,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"
@@ -5490,7 +5830,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);
@@ -5523,7 +5863,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"
@@ -5676,7 +6016,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;
@@ -6400,7 +6740,7 @@ ${r.snippet.trim()}
       if (!options.onDebugSnapshot) return;
       await options.onDebugSnapshot({
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        queryHash: createHash("sha256").update(prompt).digest("hex"),
+        queryHash: createHash2("sha256").update(prompt).digest("hex"),
         queryLength: prompt.length,
         collection: options.collection,
         namespaces: options.recallNamespaces,
@@ -6582,7 +6922,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;
       }
@@ -6607,7 +6947,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);
@@ -6650,7 +6990,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(
@@ -6666,7 +7006,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;
@@ -6691,7 +7031,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,
@@ -6712,12 +7052,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;
@@ -6729,7 +7069,7 @@ ${r.snippet.trim()}
       const payload = {
         recordedAt: now,
         mode: options.recallMode,
-        queryHash: createHash("sha256").update(options.prompt).digest("hex"),
+        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
         queryLength: options.prompt.length,
         namespaces: options.recallNamespaces,
         seedCount: totalSeedCount,
@@ -6744,20 +7084,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"
@@ -6768,13 +7108,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"
@@ -6788,9 +7128,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"
@@ -6801,12 +7141,12 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path3.join(this.config.memoryDir, "state");
+      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
@@ -6814,11 +7154,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) => ({
@@ -7071,8 +7411,8 @@ ${r.snippet.trim()}
         timings,
         logger: log
       });
-      const promptHash = createHash("sha256").update(prompt).digest("hex");
-      const traceId = createHash("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
+      const promptHash = createHash2("sha256").update(prompt).digest("hex");
+      const traceId = createHash2("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
       const sectionBuckets = /* @__PURE__ */ new Map();
       const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
         cronRecallPolicyEnabled: this.config.cronRecallPolicyEnabled,
@@ -7081,7 +7421,7 @@ ${r.snippet.trim()}
         cronConversationRecallMode: this.config.cronConversationRecallMode
       });
       const retrievalQuery = queryPolicy.retrievalQuery || prompt;
-      const retrievalQueryHash = createHash("sha256").update(retrievalQuery).digest("hex");
+      const retrievalQueryHash = createHash2("sha256").update(retrievalQuery).digest("hex");
       const policyVersion = this.currentPolicyVersion();
       let impressionRecorded = false;
       let recallSource = "none";
@@ -7220,7 +7560,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))
@@ -7370,7 +7710,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];
@@ -7852,9 +8192,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",
@@ -8073,9 +8413,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",
@@ -8846,11 +9186,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;
@@ -10535,7 +10875,7 @@ ${tmtNode.summary}`
       });
       if (this.isRecallSectionEnabled(
         "compression-guidelines",
-        this.config.compressionGuidelineLearningEnabled === true
+        resolveCompressionCapabilities(this.config).compressionGuidelineLearning === true
       )) {
         const compressionGuidelineSection = await this.buildCompressionGuidelineRecallSection();
         if (compressionGuidelineSection) {
@@ -11121,7 +11461,7 @@ _Context: ${topQuestion.context}_`
     const shouldUseStableBatchKey = turns.some(
       (turn) => turn.persistProcessedFingerprint === true || typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0
     );
-    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash("sha256").update(
+    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash2("sha256").update(
       turns.map(
         (turn) => [
           turn.role,
@@ -11371,7 +11711,7 @@ _Context: ${topQuestion.context}_`
   buildExtractionFingerprint(turns, bufferKey) {
     const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
     if (!normalized) return null;
-    return createHash("sha256").update(`${bufferKey}
+    return createHash2("sha256").update(`${bufferKey}
 ${normalized}`).digest("hex");
   }
   shouldQueueExtraction(turns, options = {}) {
@@ -13452,7 +13792,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);
           }
         }
@@ -13776,7 +14116,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"
@@ -13824,9 +14164,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"
@@ -13951,65 +14291,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");
@@ -14033,215 +14314,16 @@ ${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;
@@ -14589,7 +14671,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 {
@@ -14651,7 +14733,7 @@ ${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);
@@ -14681,7 +14763,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
@@ -14722,7 +14804,7 @@ ${lines.join("\n\n")}`;
         return null;
       }
     }
-    if (path3.isAbsolute(resultPath)) {
+    if (path4.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -14761,7 +14843,7 @@ ${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,
@@ -14785,16 +14867,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)) {
@@ -14812,7 +14894,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(
@@ -14857,7 +14939,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,
@@ -14940,7 +15022,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 {
@@ -14951,7 +15033,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;
         }
       },
@@ -15121,12 +15203,12 @@ ${lines.join("\n\n")}`;
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path3.resolve(this.config.memoryDir);
-    const storageDir = path3.resolve(targetStorage.dir);
+    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`
@@ -15145,7 +15227,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({
@@ -15342,7 +15424,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);
@@ -15366,8 +15448,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)
           )) {
@@ -16274,7 +16356,6 @@ export {
   WearablesService,
   locateTranscriptPath,
   BulkImportBatchPartialFailureError,
-  dedupeEntitySynthesisEvidenceEntries,
   defaultWorkspaceDir,
   sanitizeSessionKeyForFilename,
   isArtifactMemoryPath,
@@ -16302,4 +16383,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-Z7J3OAPR.js.map
+//# sourceMappingURL=chunk-AE2HPUP7.js.map