@remnic/core 9.3.655 → 9.3.656

package/dist/{chunk-5QD3QD76.js → chunk-RDW5G6DO.js}

@@ -29,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UYNFWZWG.js";
+} from "./chunk-AGJKWOKV.js";
 import {
   SharedContextManager
 } from "./chunk-DRD2Q7HQ.js";
@@ -56,7 +56,7 @@ import {
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
-} from "./chunk-PS3SYNHP.js";
+} from "./chunk-R5DB26G6.js";
 import {
   applyTemporalSupersession,
   normalizeSupersessionKey,
@@ -71,7 +71,7 @@ import {
 import {
   buildResponseGuidanceRecallSection,
   shouldRecallResponseGuidance
-} from "./chunk-XBIACVCO.js";
+} from "./chunk-EC2AYKRX.js";
 import {
   mergeWithAgentResults,
   runDirectAgent,
@@ -170,19 +170,19 @@ import {
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
-} from "./chunk-7LWRCOP7.js";
+} from "./chunk-LZTFCAKE.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-NRBGRZW4.js";
+} from "./chunk-IOZ5WBWD.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
 } from "./chunk-UU6MVCJ6.js";
 import {
   buildExplicitCueRecallSection
-} from "./chunk-3XGWCZ63.js";
+} from "./chunk-YXLT4EMM.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-WLEB7WCG.js";
@@ -210,7 +210,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-BGKXTVNG.js";
+} from "./chunk-SWDHVH2P.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-2PRQG7PV.js";
@@ -218,14 +218,16 @@ import {
   RoutingRulesStore
 } from "./chunk-X6IRLNOO.js";
 import {
+  compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-NCSJKK23.js";
+} from "./chunk-JSVFEHLL.js";
 import {
   ThreadingManager
 } from "./chunk-W4RVMTHR.js";
 import {
+  compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-UCEABZZN.js";
+} from "./chunk-TFFZUFEP.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -239,7 +241,7 @@ import {
   NamespaceStorageRouter,
   resolveDefaultNamespaceRoot,
   resolveNamespaceStorageRoot
-} from "./chunk-XRKQOQLY.js";
+} from "./chunk-WIKMCJUR.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -305,9 +307,11 @@ import {
 import {
   clusterByKey,
   combineNamespaces,
+  expandScopeProfileReadNamespaces,
   lcmReadSessionIdsForNamespaces,
-  resolveCodingNamespaceOverlay
-} from "./chunk-MMJANTJX.js";
+  resolveCodingNamespaceOverlay,
+  resolveScopeProfilePlan
+} from "./chunk-GYSYLGNE.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -317,7 +321,7 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-54LOUIBE.js";
+} from "./chunk-2MXEVL75.js";
 import {
   NamespaceSearchRouter
 } from "./chunk-EKQMQQ3U.js";
@@ -357,7 +361,7 @@ import {
 } from "./chunk-Y56J7CXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-PTMJ2FH2.js";
+} from "./chunk-Z6UDTNY6.js";
 import {
   ALL_CATEGORY_DIRS,
   ContentHashIndex,
@@ -368,7 +372,7 @@ import {
   normalizeEntityName,
   parseEntityFile,
   stripAttributesSuffix
-} from "./chunk-TEO46GMM.js";
+} from "./chunk-NXCK7DO7.js";
 import {
   isValidTranscriptDate,
   loadSpeakerRegistry,
@@ -383,7 +387,7 @@ import {
 } from "./chunk-J6A3CX5N.js";
 import {
   confidenceTier
-} from "./chunk-TDZSSJV4.js";
+} from "./chunk-AZBV4RRY.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus
@@ -4328,6 +4332,7 @@ var Orchestrator = class _Orchestrator {
   _peerIdBySession = /* @__PURE__ */ new Map();
   routingRulesStore = null;
   contentHashIndex = null;
+  contentHashIndexesByStorageDir = /* @__PURE__ */ new Map();
   artifactSourceStatusCache = /* @__PURE__ */ new WeakMap();
   static ARTIFACT_STATUS_CACHE_TTL_MS = 6e4;
   // Access tracking buffer (Phase 1A)
@@ -4793,6 +4798,9 @@ var Orchestrator = class _Orchestrator {
     return Object.keys(searchOptions).length > 0 ? searchOptions : void 0;
   }
   async searchAcrossNamespaces(options) {
+    if (this.config.namespacesEnabled && options.namespaces !== void 0 && options.namespaces.length === 0) {
+      return [];
+    }
     const namespaces = this.config.namespacesEnabled ? Array.from(
       new Set(
         (options.namespaces?.length ? options.namespaces : this.configuredNamespaces()).map((value) => value.trim()).filter(Boolean)
@@ -4849,6 +4857,57 @@ var Orchestrator = class _Orchestrator {
   }
   invalidateLiveContentHashIndex() {
     this.contentHashIndex = null;
+    this.contentHashIndexesByStorageDir.clear();
+  }
+  async contentHashIndexForStorage(targetStorage) {
+    if (!this.config.factDeduplicationEnabled) return null;
+    if (targetStorage.dir === this.storage.dir) {
+      if (!this.contentHashIndex) {
+        this.contentHashIndex = this.storage.createContentHashIndex();
+        await this.contentHashIndex.load();
+      }
+      return this.contentHashIndex;
+    }
+    const cached = this.contentHashIndexesByStorageDir.get(targetStorage.dir);
+    if (cached) return cached;
+    const index = targetStorage.createContentHashIndex();
+    await index.load();
+    this.contentHashIndexesByStorageDir.set(targetStorage.dir, index);
+    log.info(
+      `content-hash dedup: loaded ${index.size} hashes for storage ${targetStorage.dir}`
+    );
+    return index;
+  }
+  async hasContentHashDedup(targetStorage, content) {
+    const index = await this.contentHashIndexForStorage(targetStorage);
+    return index ? index.has(content) : false;
+  }
+  async addContentHashDedup(targetStorage, content) {
+    const index = await this.contentHashIndexForStorage(targetStorage);
+    if (!index) return;
+    index.add(content);
+  }
+  async removeContentHashForMemory(targetStorage, memory, context) {
+    const index = await this.contentHashIndexForStorage(targetStorage);
+    if (!index) return;
+    if (memory.frontmatter.contentHash) {
+      index.removeByHash(memory.frontmatter.contentHash);
+      return;
+    }
+    log.warn(
+      `[${context}] removing hash for legacy memory ${memory.frontmatter.id ?? "(unknown)"} via content fallback - no contentHash in frontmatter`
+    );
+    index.remove(memory.content);
+  }
+  async saveContentHashIndexes() {
+    const indexes = /* @__PURE__ */ new Set();
+    if (this.contentHashIndex) indexes.add(this.contentHashIndex);
+    for (const index of this.contentHashIndexesByStorageDir.values()) {
+      indexes.add(index);
+    }
+    for (const index of indexes) {
+      await index.save();
+    }
   }
   constructor(config) {
     this.config = config;
@@ -6128,16 +6187,11 @@ ${doc.content}` : doc.content,
             relatedMemoryIds: [canonicalId]
           });
           if (archiveResult) {
-            if (this.contentHashIndex) {
-              if (m.frontmatter.contentHash) {
-                this.contentHashIndex.removeByHash(m.frontmatter.contentHash);
-              } else {
-                log.warn(
-                  `[semantic-consolidation] removing hash for legacy memory ${m.frontmatter.id ?? "(unknown)"} via content fallback \u2014 no contentHash in frontmatter`
-                );
-                this.contentHashIndex.remove(m.content);
-              }
-            }
+            await this.removeContentHashForMemory(
+              targetStorage,
+              m,
+              "semantic-consolidation"
+            );
             try {
               await this.embeddingFallback.removeFromIndex(m.frontmatter.id);
               if (this.config.queryAwareIndexingEnabled && m.path && m.frontmatter?.created) {
@@ -6173,8 +6227,8 @@ ${doc.content}` : doc.content,
         }
       }
     }
-    if (result.memoriesArchived > 0 && this.contentHashIndex) {
-      await this.contentHashIndex.save().catch(
+    if (result.memoriesArchived > 0) {
+      await this.saveContentHashIndexes().catch(
         (err) => log.warn(
           `[semantic-consolidation] content-hash index save failed: ${err}`
         )
@@ -7082,7 +7136,8 @@ ${r.snippet.trim()}
           this.enqueueDirectAnswerObservation(
             prompt,
             sessionKey,
-            options.namespace?.trim() || void 0
+            options.namespace?.trim() || void 0,
+            options.principalOverride
           );
         } catch (err) {
           log.debug(`direct-answer observation setup failed: ${err}`);
@@ -7137,17 +7192,32 @@ ${r.snippet.trim()}
       if (timeoutHandle) clearTimeout(timeoutHandle);
     }
   }
-  enqueueDirectAnswerObservation(prompt, sessionKey, namespaceOverride) {
+  enqueueDirectAnswerObservation(prompt, sessionKey, namespaceOverride, principalOverride) {
     const expectedSnapshot = this.lastRecall.get(sessionKey);
     if (expectedSnapshot === null) return;
     if (expectedSnapshot.plannerMode === "no_recall") return;
-    const principal = resolvePrincipal(sessionKey, this.config);
+    const principal = principalOverride ?? resolvePrincipal(sessionKey, this.config);
     const observationCodingOverlay = namespaceOverride && canReadNamespace(principal, namespaceOverride, this.config) ? null : this.applyCodingRecallOverlay(sessionKey);
     const observationPrincipalSelf = defaultNamespaceForPrincipal(principal, this.config);
     const observationCodingSelf = observationCodingOverlay ? combineNamespaces(observationPrincipalSelf, observationCodingOverlay.namespace) : null;
+    const observationScopeProfilePlan = namespaceOverride && canReadNamespace(principal, namespaceOverride, this.config) ? null : resolveScopeProfilePlan({
+      config: this.config,
+      principal,
+      codingContext: sessionKey ? this.getCodingContextForSession(sessionKey) : null,
+      codingOverlay: observationCodingOverlay
+    });
     let observationNamespaces;
     if (namespaceOverride && canReadNamespace(principal, namespaceOverride, this.config)) {
       observationNamespaces = [namespaceOverride];
+    } else if (observationScopeProfilePlan) {
+      observationNamespaces = expandScopeProfileReadNamespaces({
+        profilePlan: observationScopeProfilePlan,
+        principalSelfNamespace: observationScopeProfilePlan.baseNamespace,
+        config: this.config,
+        principal,
+        codingOverlay: observationCodingOverlay,
+        legacyRecallNamespaces: recallNamespacesForPrincipal(principal, this.config)
+      });
     } else if (observationCodingOverlay && observationCodingSelf) {
       const base = recallNamespacesForPrincipal(principal, this.config);
       const mapped = base.map(
@@ -8280,10 +8350,26 @@ ${r.snippet.trim()}
       const codingOverlay = namespaceOverride ? null : this.applyCodingRecallOverlay(sessionKey);
       const principalSelfNamespace = defaultNamespaceForPrincipal(principal, this.config);
       const codingSelfNamespace = codingOverlay ? combineNamespaces(principalSelfNamespace, codingOverlay.namespace) : null;
-      const selfNamespace = namespaceOverride ?? codingSelfNamespace ?? principalSelfNamespace;
+      const scopeProfilePlan = namespaceOverride ? null : resolveScopeProfilePlan({
+        config: this.config,
+        principal,
+        codingContext: sessionKey ? this.getCodingContextForSession(sessionKey) : null,
+        codingOverlay
+      });
+      const profileEffectiveNamespace = scopeProfilePlan?.writeNamespace || scopeProfilePlan?.readNamespaces[0];
+      const selfNamespace = namespaceOverride ?? profileEffectiveNamespace ?? codingSelfNamespace ?? principalSelfNamespace;
       let recallNamespaces;
       if (namespaceOverride) {
         recallNamespaces = [namespaceOverride];
+      } else if (scopeProfilePlan) {
+        recallNamespaces = expandScopeProfileReadNamespaces({
+          profilePlan: scopeProfilePlan,
+          principalSelfNamespace: scopeProfilePlan.baseNamespace,
+          config: this.config,
+          principal,
+          codingOverlay,
+          legacyRecallNamespaces: readableRecallNamespaces
+        });
       } else if (codingOverlay && codingSelfNamespace) {
         const mapped = readableRecallNamespaces.map(
           (ns) => ns === principalSelfNamespace ? codingSelfNamespace : ns
@@ -8295,10 +8381,12 @@ ${r.snippet.trim()}
       } else {
         recallNamespaces = readableRecallNamespaces;
       }
-      const codingOverlaySelfReadable = codingOverlay !== null && readableRecallNamespaces.includes(principalSelfNamespace);
+      const codingOverlaySelfReadable = codingOverlay !== null && (scopeProfilePlan ? scopeProfilePlan.layers.some((layer) => layer.id === "userProject" && layer.readable) : readableRecallNamespaces.includes(principalSelfNamespace));
       let lcmReadNamespaces;
       if (namespaceOverride) {
         lcmReadNamespaces = [namespaceOverride];
+      } else if (scopeProfilePlan) {
+        lcmReadNamespaces = recallNamespaces;
       } else if (codingOverlay && codingSelfNamespace && codingOverlaySelfReadable) {
         const fallbackNs = codingOverlay.readFallbacks.map(
           (fallback) => combineNamespaces(principalSelfNamespace, fallback)
@@ -8307,7 +8395,7 @@ ${r.snippet.trim()}
       } else {
         lcmReadNamespaces = [this.config.defaultNamespace];
       }
-      const lcmReadSessionIds = lcmReadSessionIdsForNamespaces(
+      const lcmReadSessionIds = scopeProfilePlan && !sessionKey ? [] : lcmReadSessionIdsForNamespaces(
         lcmReadNamespaces,
         sessionKey,
         this.config.defaultNamespace
@@ -8480,7 +8568,144 @@ ${r.snippet.trim()}
         });
         return "";
       }
-      const profileStorage = await this.storageRouter.storageFor(selfNamespace);
+      const profileStorageNamespaces = scopeProfilePlan ? recallNamespaces : [selfNamespace];
+      const profileStorages = await Promise.all(
+        profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
+      );
+      const emptyProfileStorage = new Proxy(
+        { dir: path4.join(this.config.memoryDir, ".empty-scope-profile") },
+        {
+          get(target, prop) {
+            if (prop in target) return target[prop];
+            if (prop === "readProfile") return async () => "";
+            if (prop === "readQuestions" || prop === "listEntityNames" || prop === "readContinuityIncidents")
+              return async () => [];
+            if (prop === "readIdentityAnchor" || prop === "readIdentityImprovementLoops")
+              return async () => "";
+            if (prop === "readEntity" || prop === "readMemoryByPath")
+              return async () => null;
+            return async () => [];
+          }
+        }
+      );
+      const profileStorage = profileStorages.length <= 1 ? profileStorages[0] ?? emptyProfileStorage : new Proxy(profileStorages[0], {
+        get(target, prop) {
+          if (prop === "readProfile") {
+            return async () => {
+              for (const storage of profileStorages) {
+                const profile2 = await storage.readProfile();
+                if (profile2.trim().length > 0) return profile2;
+              }
+              return "";
+            };
+          }
+          if (prop === "readQuestions") {
+            return async (...args) => {
+              const merged = [];
+              const seen = /* @__PURE__ */ new Set();
+              const priorityOf = (question) => {
+                const priority = Number(question?.priority ?? 0);
+                return Number.isFinite(priority) ? priority : 0;
+              };
+              for (const storage of profileStorages) {
+                const questions = await storage.readQuestions(...args);
+                for (const question of questions) {
+                  const key = typeof question === "string" ? question : JSON.stringify(question);
+                  if (seen.has(key)) continue;
+                  seen.add(key);
+                  merged.push(question);
+                }
+              }
+              return merged.sort(
+                (left, right) => priorityOf(right) - priorityOf(left) || String(left?.id ?? "").localeCompare(String(right?.id ?? ""))
+              );
+            };
+          }
+          if (prop === "readIdentityAnchor") {
+            return async () => {
+              for (const storage of profileStorages) {
+                const anchor = await storage.readIdentityAnchor() ?? "";
+                if (anchor.trim().length > 0) return anchor;
+              }
+              return "";
+            };
+          }
+          if (prop === "readIdentityImprovementLoops") {
+            return async () => {
+              const sections = [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const storage of profileStorages) {
+                const loops = (await storage.readIdentityImprovementLoops() ?? "").trim();
+                if (!loops || seen.has(loops)) continue;
+                seen.add(loops);
+                sections.push(loops);
+              }
+              return sections.join("\n\n");
+            };
+          }
+          if (prop === "readContinuityIncidents") {
+            return async (...args) => {
+              const limit = typeof args[0] === "number" && Number.isFinite(args[0]) ? Math.max(0, args[0]) : void 0;
+              const incidents = [];
+              const seen = /* @__PURE__ */ new Set();
+              const incidentTime = (incident) => {
+                const raw = incident?.updatedAt ?? incident?.openedAt ?? incident?.createdAt;
+                const parsed = typeof raw === "string" ? Date.parse(raw) : Number.NaN;
+                return Number.isFinite(parsed) ? parsed : 0;
+              };
+              for (const storage of profileStorages) {
+                for (const incident of await storage.readContinuityIncidents(...args)) {
+                  const key = JSON.stringify(incident);
+                  if (seen.has(key)) continue;
+                  seen.add(key);
+                  incidents.push(incident);
+                }
+              }
+              incidents.sort(
+                (left, right) => incidentTime(right) - incidentTime(left) || String(left?.id ?? "").localeCompare(String(right?.id ?? ""))
+              );
+              return limit === void 0 ? incidents : incidents.slice(0, limit);
+            };
+          }
+          if (prop === "listEntityNames") {
+            return async (...args) => {
+              const names = /* @__PURE__ */ new Set();
+              for (const storage of profileStorages) {
+                for (const name of await storage.listEntityNames(...args)) names.add(name);
+              }
+              return [...names];
+            };
+          }
+          if (prop === "readEntity" || prop === "readMemoryByPath") {
+            return async (...args) => {
+              for (const storage of profileStorages) {
+                const value = await storage[prop](...args);
+                if (value) return value;
+              }
+              return null;
+            };
+          }
+          if (prop === "readAllMemories") {
+            return async (...args) => {
+              const memories = [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const storage of profileStorages) {
+                for (const memory of await storage.readAllMemories(...args)) {
+                  const key = String(memory?.path ?? memory?.frontmatter?.id ?? JSON.stringify(memory));
+                  if (seen.has(key)) continue;
+                  seen.add(key);
+                  memories.push(memory);
+                }
+              }
+              return memories;
+            };
+          }
+          return target[prop];
+        }
+      });
+      const profileStorageDirs = Array.from(
+        new Set(profileStorages.map((storage) => storage.dir).filter((dir) => typeof dir === "string" && dir.length > 0))
+      );
       throwIfRecallAborted(options.abortSignal);
       if (this.namespaceCatalog.enabled && recallResultLimit > 0 && !options.abortSignal?.aborted) {
         for (const ns of recallNamespaces) this.markCatalogRead(ns);
@@ -8492,6 +8717,8 @@ ${r.snippet.trim()}
         ))
           return null;
         if (!this.sharedContext) return null;
+        if (scopeProfilePlan && !(scopeProfilePlan.profile.readOrder.includes("serverShared") && scopeProfilePlan.readNamespaces.includes(this.config.sharedNamespace)))
+          return null;
         const t0 = Date.now();
         const [priorities, roundtable, crossSignals] = await Promise.all([
           this.sharedContext.readPriorities(),
@@ -8716,13 +8943,52 @@ ${lines.join("\n\n")}`;
         if (!this.config.knowledgeIndexEnabled) return null;
         const t0 = Date.now();
         try {
-          const ki = await this.storage.buildKnowledgeIndex(this.config, {
-            maxEntities: this.getRecallSectionNumber(
-              "knowledge-index",
-              "maxEntities"
-            ),
-            maxChars: this.getRecallSectionNumber("knowledge-index", "maxChars")
-          });
+          const knowledgeIndexMaxChars = this.getRecallSectionNumber("knowledge-index", "maxChars") ?? this.config.knowledgeIndexMaxChars;
+          const knowledgeIndexMaxEntities = this.getRecallSectionNumber("knowledge-index", "maxEntities") ?? this.config.knowledgeIndexMaxEntities;
+          const knowledgeIndexOptions = {
+            maxEntities: knowledgeIndexMaxEntities,
+            maxChars: knowledgeIndexMaxChars
+          };
+          const ki = scopeProfilePlan ? await (async () => {
+            const perLayerOptions = {
+              ...knowledgeIndexOptions,
+              maxEntities: Number.MAX_SAFE_INTEGER,
+              maxChars: Number.MAX_SAFE_INTEGER
+            };
+            const results = await Promise.all(
+              profileStorages.map(
+                (storage) => storage.buildKnowledgeIndex(this.config, perLayerOptions)
+              )
+            );
+            const sections = results.map((result) => result.result.trim()).filter((section) => section.length > 0);
+            const maxRows = Math.max(0, Math.floor(knowledgeIndexMaxEntities));
+            const rows = [];
+            let header = null;
+            for (const section of sections) {
+              const lines = section.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0);
+              const tableHeaderIndex = lines.findIndex(
+                (line) => line.startsWith("| Entity |")
+              );
+              if (tableHeaderIndex === -1) continue;
+              header ??= lines.slice(0, tableHeaderIndex + 2);
+              for (const row of lines.slice(tableHeaderIndex + 2)) {
+                if (!row.startsWith("|")) continue;
+                if (rows.length >= maxRows) break;
+                rows.push(row);
+              }
+              if (rows.length >= maxRows) break;
+            }
+            const merged = header && rows.length > 0 ? `${header.join("\n")}
+${rows.join("\n")}
+` : "";
+            return {
+              result: this.truncateRecallSectionToBudget(
+                merged,
+                knowledgeIndexMaxChars
+              ),
+              cached: results.every((result) => result.cached)
+            };
+          })() : await this.storage.buildKnowledgeIndex(this.config, knowledgeIndexOptions);
           recordRecallSectionMetric({
             section: "ki",
             priority: "core",
@@ -9089,15 +9355,30 @@ ${lines.join("\n\n")}`;
             });
             return null;
           }
-          const results = await searchHarmonicRetrieval({
-            memoryDir: this.config.memoryDir,
-            abstractionNodeStoreDir: this.config.abstractionNodeStoreDir,
-            query: retrievalQuery,
-            maxResults,
-            sessionKey,
-            anchorsEnabled: this.config.abstractionAnchorsEnabled,
-            abortSignal: harmonicRetrievalAbort.signal
-          });
+          const harmonicSearchDirs = scopeProfilePlan ? profileStorageDirs : [this.config.memoryDir];
+          const harmonicResultsByDir = await Promise.all(
+            harmonicSearchDirs.map(
+              (memoryDir) => searchHarmonicRetrieval({
+                memoryDir,
+                abstractionNodeStoreDir: scopeProfilePlan ? void 0 : this.config.abstractionNodeStoreDir,
+                query: retrievalQuery,
+                maxResults,
+                sessionKey,
+                anchorsEnabled: this.config.abstractionAnchorsEnabled,
+                abortSignal: harmonicRetrievalAbort.signal
+              })
+            )
+          );
+          const harmonicByNodeId = /* @__PURE__ */ new Map();
+          for (const result of harmonicResultsByDir.flat()) {
+            const existing = harmonicByNodeId.get(result.node.nodeId);
+            if (!existing || result.score > existing.score) {
+              harmonicByNodeId.set(result.node.nodeId, result);
+            }
+          }
+          const results = [...harmonicByNodeId.values()].sort(
+            (left, right) => right.score - left.score || right.anchorScore - left.anchorScore || right.node.recordedAt.localeCompare(left.node.recordedAt) || left.node.nodeId.localeCompare(right.node.nodeId)
+          ).slice(0, maxResults);
           recordRecallSectionMetric({
             section: "harmonicRetrieval",
             priority: "enrichment",
@@ -9143,11 +9424,28 @@ ${lines.join("\n\n")}`;
         const VERIFIED_RECALL_TIMEOUT_MS = 15e3;
         let timeoutHandle;
         const results = await Promise.race([
-          searchVerifiedEpisodes({
-            memoryDir: profileStorage.dir,
-            query: retrievalQuery,
-            maxResults,
-            boxRecallDays: this.config.boxRecallDays
+          Promise.all(
+            profileStorageDirs.map(
+              (memoryDir) => searchVerifiedEpisodes({
+                memoryDir,
+                query: retrievalQuery,
+                maxResults,
+                boxRecallDays: this.config.boxRecallDays
+              }).catch((err) => {
+                log.debug(`verified recall directory scan failed: ${err}`);
+                return [];
+              })
+            )
+          ).then((groups) => {
+            const merged = [];
+            const seen = /* @__PURE__ */ new Set();
+            for (const result of groups.flat()) {
+              const key = result.box.id || JSON.stringify(result);
+              if (seen.has(key)) continue;
+              seen.add(key);
+              merged.push(result);
+            }
+            return merged.sort(compareVerifiedEpisodeResults).slice(0, maxResults);
           }),
           new Promise((resolve) => {
             timeoutHandle = setTimeout(
@@ -9206,10 +9504,27 @@ ${lines.join("\n\n")}`;
         const VERIFIED_RULES_TIMEOUT_MS = 15e3;
         let rulesTimeoutHandle;
         const results = await Promise.race([
-          searchVerifiedSemanticRules({
-            memoryDir: this.config.memoryDir,
-            query: retrievalQuery,
-            maxResults
+          Promise.all(
+            profileStorageDirs.map(
+              (memoryDir) => searchVerifiedSemanticRules({
+                memoryDir,
+                query: retrievalQuery,
+                maxResults
+              }).catch((err) => {
+                log.debug(`verified rules directory scan failed: ${err}`);
+                return [];
+              })
+            )
+          ).then((groups) => {
+            const merged = [];
+            const seen = /* @__PURE__ */ new Set();
+            for (const result of groups.flat()) {
+              const key = result.rule.frontmatter.id || result.rule.path || JSON.stringify(result);
+              if (seen.has(key)) continue;
+              seen.add(key);
+              merged.push(result);
+            }
+            return merged.sort(compareVerifiedSemanticRuleResults).slice(0, maxResults);
           }),
           new Promise((resolve) => {
             rulesTimeoutHandle = setTimeout(
@@ -9265,13 +9580,28 @@ ${lines.join("\n\n")}`;
           });
           return null;
         }
-        const results = await searchWorkProductLedgerEntries({
-          memoryDir: this.config.memoryDir,
-          workProductLedgerDir: this.config.workProductLedgerDir,
-          query: retrievalQuery,
-          maxResults,
-          sessionKey
-        });
+        const workProductSearchDirs = scopeProfilePlan ? profileStorageDirs : [this.config.memoryDir];
+        const workProductResultsByDir = await Promise.all(
+          workProductSearchDirs.map(
+            (memoryDir) => searchWorkProductLedgerEntries({
+              memoryDir,
+              workProductLedgerDir: scopeProfilePlan ? void 0 : this.config.workProductLedgerDir,
+              query: retrievalQuery,
+              maxResults,
+              sessionKey
+            })
+          )
+        );
+        const workProductByEntryId = /* @__PURE__ */ new Map();
+        for (const result of workProductResultsByDir.flat()) {
+          const existing = workProductByEntryId.get(result.entry.entryId);
+          if (!existing || result.score > existing.score) {
+            workProductByEntryId.set(result.entry.entryId, result);
+          }
+        }
+        const results = [...workProductByEntryId.values()].sort(
+          (left, right) => right.score - left.score || right.entry.recordedAt.localeCompare(left.entry.recordedAt) || left.entry.entryId.localeCompare(right.entry.entryId)
+        ).slice(0, maxResults);
         recordRecallSectionMetric({
           section: "workProducts",
           priority: "core",
@@ -9445,22 +9775,50 @@ ${lines.join("\n\n")}`;
           }
           const maxPerAgent = this.config.parallelMaxResultsPerAgent;
           const specializedAgentPromise = !queryAwarePrefilterIsEmpty && this.config.parallelRetrievalEnabled && maxPerAgent > 0 ? Promise.all([
-            shouldRunAgent("direct", retrievalQuery, 0) ? runDirectAgent(
-              retrievalQuery,
-              profileStorage.dir,
-              maxPerAgent
-            ).catch((err) => {
-              log.debug(`DirectAgent pre-start failed: ${err}`);
-              return [];
+            shouldRunAgent("direct", retrievalQuery, 0) ? Promise.all(
+              profileStorageDirs.map(
+                (memoryDir) => runDirectAgent(
+                  retrievalQuery,
+                  memoryDir,
+                  maxPerAgent
+                ).catch((err) => {
+                  log.debug(`DirectAgent pre-start failed: ${err}`);
+                  return [];
+                })
+              )
+            ).then((groups) => {
+              const merged = [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const result of groups.flat()) {
+                const key = result.path ?? JSON.stringify(result);
+                if (seen.has(key)) continue;
+                seen.add(key);
+                merged.push(result);
+              }
+              return merged.sort((a, b) => b.score - a.score).slice(0, maxPerAgent);
             }) : Promise.resolve([]),
-            shouldRunAgent("temporal", retrievalQuery, 0) ? runTemporalAgent(
-              retrievalQuery,
-              this.config.memoryDir,
-              maxPerAgent,
-              queryAwarePrefilter.candidatePaths
-            ).catch((err) => {
-              log.debug(`TemporalAgent pre-start failed: ${err}`);
-              return [];
+            shouldRunAgent("temporal", retrievalQuery, 0) ? Promise.all(
+              profileStorageDirs.map(
+                (memoryDir) => runTemporalAgent(
+                  retrievalQuery,
+                  memoryDir,
+                  maxPerAgent,
+                  queryAwarePrefilter.candidatePaths
+                ).catch((err) => {
+                  log.debug(`TemporalAgent pre-start failed for ${memoryDir}: ${err}`);
+                  return [];
+                })
+              )
+            ).then((groups) => {
+              const merged = [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const result of groups.flat()) {
+                const key = result.path ?? JSON.stringify(result);
+                if (seen.has(key)) continue;
+                seen.add(key);
+                merged.push(result);
+              }
+              return merged.sort((a, b) => b.score - a.score).slice(0, maxPerAgent);
             }) : Promise.resolve([])
           ]) : null;
           try {
@@ -9935,7 +10293,27 @@ ${formatted}`;
         this.isRecallSectionEnabled(
           "memory-boxes",
           this.config.memoryBoxesEnabled === true
-        ) && this.config.memoryBoxesEnabled && this.config.boxRecallDays > 0 ? this.boxBuilderFor(profileStorage).readRecentBoxes(this.config.boxRecallDays).catch(() => []) : Promise.resolve([])
+        ) && this.config.memoryBoxesEnabled && this.config.boxRecallDays > 0 ? Promise.all(
+          profileStorages.map(
+            (storage) => this.boxBuilderFor(storage).readRecentBoxes(this.config.boxRecallDays).catch(() => [])
+          )
+        ).then((groups) => {
+          const boxes = [];
+          const seen = /* @__PURE__ */ new Set();
+          for (const box of groups.flat()) {
+            const key = JSON.stringify(box);
+            if (seen.has(key)) continue;
+            seen.add(key);
+            boxes.push(box);
+          }
+          return boxes.sort((a, b) => {
+            const aTime = Date.parse(a.sealedAt ?? "");
+            const bTime = Date.parse(b.sealedAt ?? "");
+            const aRank = Number.isFinite(aTime) ? aTime : 0;
+            const bRank = Number.isFinite(bTime) ? bTime : 0;
+            return bRank - aRank;
+          });
+        }) : Promise.resolve([])
       );
       this.profiler.startSpan("phase-1-parallel", profileTraceId);
       const phase1Start = Date.now();
@@ -12192,7 +12570,41 @@ ${normalized}`).digest("hex");
       };
     }
     const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-    const selfNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : this.applyCodingNamespaceOverlay(
+    const explicitWriteNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
+    const codingContextForWrite = sessionKey ? this.getCodingContextForSession(sessionKey) : null;
+    const codingOverlayForWrite = resolveCodingNamespaceOverlay(
+      codingContextForWrite,
+      this.config.codingMode,
+      this.config.defaultNamespace
+    );
+    const scopeProfileGatePlan = resolveScopeProfilePlan({
+      config: this.config,
+      principal,
+      codingContext: codingContextForWrite,
+      codingOverlay: codingOverlayForWrite
+    });
+    const scopeProfileWritePlan = explicitWriteNamespace ? null : scopeProfileGatePlan;
+    if (scopeProfileWritePlan) {
+      const selectedLayer = scopeProfileWritePlan.layers.find(
+        (layer) => layer.id === scopeProfileWritePlan.writeLayer
+      );
+      const writeNamespaceReadable = scopeProfileWritePlan.readNamespaces.includes(
+        scopeProfileWritePlan.writeNamespace
+      );
+      if (!selectedLayer?.writable || !writeNamespaceReadable) {
+        log.warn(
+          `runExtraction: skipping scope profile ${scopeProfileWritePlan.profileId} because write layer ${scopeProfileWritePlan.writeLayer} is not writable inside the profile read stack`
+        );
+        await clearBuffer();
+        return {
+          status: "skipped",
+          reason: "scope_profile_no_writable_layer",
+          persistedCount: 0,
+          durableOutputCount: 0
+        };
+      }
+    }
+    const selfNamespace = explicitWriteNamespace ?? scopeProfileWritePlan?.writeNamespace ?? this.applyCodingNamespaceOverlay(
       sessionKey,
       defaultNamespaceForPrincipal(principal, this.config)
     );
@@ -12320,7 +12732,8 @@ ${normalized}`).digest("hex");
       { sessionKey, principal, validAt: sourceValidAt },
       // Pass the KNOWN base namespace (NHIdx) so the catalog write touch records the
       // real namespace rather than a guess decoded from the storage dir.
-      selfNamespace
+      selfNamespace,
+      scopeProfileGatePlan
     );
     let postPersistMetadataFailed = false;
     meta ??= await storage.loadMeta();
@@ -12748,7 +13161,7 @@ ${normalized}`).digest("hex");
       }
     }
   }
-  async persistExtraction(result, storage, threadIdForExtraction, sourceContext, baseNamespace) {
+  async persistExtraction(result, storage, threadIdForExtraction, sourceContext, baseNamespace, scopeProfileWritePlan) {
     const citationEnabled = this.config.inlineSourceAttributionEnabled === true;
     const citationTemplate = this.config.inlineSourceAttributionFormat;
     const citationContextBase = citationEnabled ? {
@@ -12802,22 +13215,128 @@ ${normalized}`).digest("hex");
       "inferred",
       "speculative"
     ];
+    const sharedProfileLayer = scopeProfileWritePlan?.layers.find(
+      (layer) => layer.id === "serverShared" && layer.namespace === this.config.sharedNamespace
+    );
+    const sharedPromotionTarget = scopeProfileWritePlan?.promotionTargets.find(
+      (target) => target.target === "serverShared" && target.namespace === this.config.sharedNamespace
+    );
+    const profileAllowsSharedWrites = !scopeProfileWritePlan || Boolean(
+      scopeProfileWritePlan.profile.readOrder.includes("serverShared") && scopeProfileWritePlan.readNamespaces.includes(this.config.sharedNamespace) && sharedProfileLayer?.readable && sharedProfileLayer.writable && sharedPromotionTarget?.authorized
+    );
+    const profileAutoPromotionAllows = (category, confidence) => {
+      if (!scopeProfileWritePlan) return false;
+      const actualTier = confidenceTier(confidence);
+      const actualRank = confidenceTierOrder.indexOf(actualTier);
+      if (actualRank === -1) return false;
+      const autoPromote = scopeProfileWritePlan.profile.autoPromote;
+      if (!autoPromote.enabled) return false;
+      if (!autoPromote.categories.includes(category)) return false;
+      const minimumRank = confidenceTierOrder.indexOf(autoPromote.minConfidenceTier);
+      return minimumRank !== -1 && actualRank <= minimumRank;
+    };
+    const sharedAutoPromotionAllows = (category, confidence) => {
+      if (!scopeProfileWritePlan) {
+        const actualTier = confidenceTier(confidence);
+        const actualRank = confidenceTierOrder.indexOf(actualTier);
+        if (actualRank === -1) return false;
+        if (!this.config.autoPromoteToSharedEnabled) return false;
+        if (!this.config.autoPromoteToSharedCategories.includes(category))
+          return false;
+        const minimumRank = confidenceTierOrder.indexOf(
+          this.config.autoPromoteMinConfidenceTier
+        );
+        return minimumRank !== -1 && actualRank <= minimumRank;
+      }
+      return scopeProfileWritePlan.profile.autoPromote.targets.includes("serverShared") && profileAutoPromotionAllows(category, confidence);
+    };
     const shouldPromoteToShared = (targetStorage, category, confidence) => {
-      if (!this.config.namespacesEnabled || !this.config.autoPromoteToSharedEnabled)
+      if (!this.config.namespacesEnabled || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(category, confidence))
         return false;
       if (this.namespaceFromStorageDir(targetStorage.dir) === this.config.sharedNamespace)
         return false;
-      if (!this.config.autoPromoteToSharedCategories.includes(category))
-        return false;
-      const actualTier = confidenceTier(confidence);
-      const actualRank = confidenceTierOrder.indexOf(actualTier);
-      const minimumRank = confidenceTierOrder.indexOf(
-        this.config.autoPromoteMinConfidenceTier
+      return true;
+    };
+    const promoteMemoryToProfileTargets = async (options) => {
+      if (!scopeProfileWritePlan || !profileAutoPromotionAllows(options.category, options.confidence))
+        return;
+      const autoTargets = new Set(scopeProfileWritePlan.profile.autoPromote.targets);
+      const targets = scopeProfileWritePlan.promotionTargets.filter(
+        (target) => target.target !== "serverShared" && autoTargets.has(target.target) && target.authorized && target.namespace
       );
-      if (actualRank === -1 || minimumRank === -1) return false;
-      return actualRank <= minimumRank;
+      if (targets.length === 0) return;
+      const rawContent = citationEnabled && hasCitationForTemplate(options.content, citationTemplate) ? stripCitationForTemplate(options.content, citationTemplate) : options.content;
+      const citedContent = applyInlineCitation(rawContent);
+      const sanitizedBase = sanitizeMemoryContent(rawContent);
+      const dedupContent = options.category === "fact" && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0 ? `${sanitizedBase.text}
+[Attributes: ${normalizeAttributePairs(options.structuredAttributes)}]` : sanitizedBase.text;
+      for (const target of targets) {
+        if (!target.namespace) continue;
+        try {
+          const targetStorage = await this.storageRouter.storageFor(target.namespace);
+          if (targetStorage.dir === options.sourceStorage.dir) continue;
+          if (options.category === "fact" && await targetStorage.hasFactContentHash(dedupContent)) {
+            continue;
+          }
+          const promotedId = await targetStorage.writeMemory(
+            options.category,
+            citedContent,
+            {
+              confidence: options.confidence,
+              tags: [...options.tags, `${target.target}-promotion`],
+              entityRef: options.entityRef,
+              structuredAttributes: options.structuredAttributes,
+              source: `${options.source}-${target.target}-promotion`,
+              importance: options.importance,
+              lineage: [options.sourceMemoryId],
+              sourceMemoryId: options.sourceMemoryId,
+              intentGoal: options.intentGoal,
+              intentActionType: options.intentActionType,
+              intentEntityTypes: options.intentEntityTypes,
+              memoryKind: options.memoryKind,
+              validAt: options.validAt,
+              contentHashSource: options.category === "fact" ? dedupContent : rawContent
+            }
+          );
+          if (this.config.temporalSupersessionEnabled && options.category === "fact" && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
+            try {
+              await applyTemporalSupersession({
+                storage: targetStorage,
+                newMemoryId: promotedId,
+                entityRef: options.entityRef,
+                structuredAttributes: options.structuredAttributes,
+                createdAt: supersessionOrderingAt(options.validAt),
+                enabled: true
+              });
+            } catch (profileSupersessionErr) {
+              log.warn(
+                `persistExtraction: ${target.target} promotion temporal supersession failed open for promoted ${promotedId}: ${profileSupersessionErr}`
+              );
+            }
+          }
+          this.markCatalogWrite(target.namespace, targetStorage.dir);
+          trackPersistedId(targetStorage, promotedId, { includeReturnedIds: false });
+          await this.indexPersistedMemory(targetStorage, promotedId);
+          trackBehaviorSignals(
+            targetStorage,
+            buildBehaviorSignalsForMemory({
+              memoryId: promotedId,
+              category: options.category,
+              content: options.content,
+              namespace: target.namespace,
+              confidence: options.confidence,
+              source: "extraction"
+            })
+          );
+        } catch (err) {
+          log.warn(
+            `persistExtraction: ${target.target} promotion failed open for ${options.sourceMemoryId}: ${err}`
+          );
+        }
+      }
     };
     const promoteMemoryToShared = async (options) => {
+      await promoteMemoryToProfileTargets(options);
       if (!shouldPromoteToShared(
         options.sourceStorage,
         options.category,
@@ -12904,11 +13423,10 @@ ${normalized}`).digest("hex");
             intentEntityTypes: options.intentEntityTypes,
             memoryKind: options.memoryKind,
             validAt: options.validAt,
-            // Index the RAW content hash so hasFactContentHash(rawContent)
-            // returns true on subsequent extractions. Without this, the index
-            // would record the hash of citedContent (which changes every call
-            // due to an updated timestamp), causing duplicate promotions.
-            contentHashSource: rawContent
+            // Index the same canonical body used by hasFactContentHash above.
+            // For structured facts this includes the normalized Attributes
+            // suffix, matching StorageManager.writeMemory enrichment.
+            contentHashSource: options.category === "fact" ? dedupContent : rawContent
           }
         );
         if (this.config.temporalSupersessionEnabled && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
@@ -13182,7 +13700,7 @@ ${normalized}`).digest("hex");
       }
       if (this.config.extractionScopeClassificationEnabled && this.config.namespacesEnabled && fact.scope === "global" && !routedNamespaceExplicit) {
         const currentNs = this.namespaceFromStorageDir(targetStorage.dir);
-        if (currentNs !== this.config.sharedNamespace) {
+        if (currentNs !== this.config.sharedNamespace && profileAllowsSharedWrites) {
           try {
             targetStorage = await this.storageRouter.storageFor(
               this.config.sharedNamespace
@@ -13196,13 +13714,28 @@ ${normalized}`).digest("hex");
               `scope-routing: failed to resolve shared namespace storage; writing to session namespace (fail-open): ${scopeRouteErr}`
             );
           }
+        } else if (currentNs !== this.config.sharedNamespace) {
+          log.debug(
+            `scope-routing: skipped shared namespace for global fact because active scope profile ${scopeProfileWritePlan?.profileId ?? "none"} does not authorize serverShared writes`
+          );
         }
       }
       const canonicalContentForHash = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
       const contentHashDedupKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalContentForHash;
-      if (this.contentHashIndex && this.contentHashIndex.has(contentHashDedupKey)) {
+      let exactDuplicate = false;
+      try {
+        exactDuplicate = await this.hasContentHashDedup(
+          targetStorage,
+          contentHashDedupKey
+        );
+      } catch (err) {
+        log.warn(
+          `content-hash dedup lookup failed for storage ${targetStorage.dir}; writing fact fail-open: ${err}`
+        );
+      }
+      if (exactDuplicate) {
         log.debug(
-          `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}\u2026"`
+          `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}\u2026" in storage ${targetStorage.dir}`
         );
         dedupedCount++;
         continue;
@@ -13465,9 +13998,13 @@ ${normalized}`).digest("hex");
             validAt: sourceContext?.validAt,
             source: extractionWriteSource
           });
-          if (this.contentHashIndex) {
+          try {
             const canonicalChunkedContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
-            this.contentHashIndex.add(canonicalChunkedContent);
+            await this.addContentHashDedup(targetStorage, canonicalChunkedContent);
+          } catch (err) {
+            log.warn(
+              `content-hash dedup registration failed for chunked memory ${parentId}: ${err}`
+            );
           }
           for (const chunk of chunkResult.chunks) {
             const chunkId = `${parentId}-chunk-${chunk.index}`;
@@ -13669,10 +14206,14 @@ ${normalized}`).digest("hex");
             intentEntityTypes: inferredIntent?.entityTypes
           });
         }
-        if (this.contentHashIndex) {
+        try {
           const canonicalFactContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
           const hashRegisterKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalFactContent;
-          this.contentHashIndex.add(hashRegisterKey);
+          await this.addContentHashDedup(targetStorage, hashRegisterKey);
+        } catch (err) {
+          log.warn(
+            `content-hash dedup registration failed for memory ${memoryId}: ${err}`
+          );
         }
       } finally {
         this.markCatalogWrite(targetNamespaceName, targetStorage.dir);
@@ -13772,9 +14313,9 @@ ${normalized}`).digest("hex");
     if (durableNonFactWritten) {
       touchBaseNonFactNamespace();
     }
-    if (this.contentHashIndex) {
-      await this.contentHashIndex.save().catch((err) => log.warn(`content-hash index save failed: ${err}`));
-    }
+    await this.saveContentHashIndexes().catch(
+      (err) => log.warn(`content-hash index save failed: ${err}`)
+    );
     for (const {
       storage: targetStorage,
       events
@@ -14729,16 +15270,11 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       if (accessCount > this.config.factArchivalMaxAccessCount) continue;
       const result = await this.storage.archiveMemory(memory);
       if (result) {
-        if (this.contentHashIndex) {
-          if (memory.frontmatter.contentHash) {
-            this.contentHashIndex.removeByHash(memory.frontmatter.contentHash);
-          } else {
-            log.warn(
-              `[fact-archival] removing hash for legacy memory ${memory.frontmatter.id ?? "(unknown)"} via content fallback \u2014 no contentHash in frontmatter`
-            );
-            this.contentHashIndex.remove(memory.content);
-          }
-        }
+        await this.removeContentHashForMemory(
+          this.storage,
+          memory,
+          "fact-archival"
+        );
         await this.embeddingFallback.removeFromIndex(memory.frontmatter.id);
         if (this.config.queryAwareIndexingEnabled && memory.path && memory.frontmatter?.created) {
           deindexMemory(
@@ -14751,8 +15287,8 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         archivedCount++;
       }
     }
-    if (archivedCount > 0 && this.contentHashIndex) {
-      await this.contentHashIndex.save().catch(
+    if (archivedCount > 0) {
+      await this.saveContentHashIndexes().catch(
         (err) => log.warn(`content-hash index save failed during archival: ${err}`)
       );
     }
@@ -16707,4 +17243,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-5QD3QD76.js.map
+//# sourceMappingURL=chunk-RDW5G6DO.js.map