@remnic/core 9.3.654 → 9.3.656

package/dist/{chunk-OL2364SB.js → chunk-RDW5G6DO.js}

@@ -29,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-ZCORQM74.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-NCGWXCSW.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-T2C6QJG2.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-QKK64Z6M.js";
+} from "./chunk-JSVFEHLL.js";
 import {
   ThreadingManager
 } from "./chunk-W4RVMTHR.js";
 import {
+  compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-K6X553JB.js";
+} from "./chunk-TFFZUFEP.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -239,7 +241,7 @@ import {
   NamespaceStorageRouter,
   resolveDefaultNamespaceRoot,
   resolveNamespaceStorageRoot
-} from "./chunk-3RACUBII.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,14 +321,14 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-FVRBLJP6.js";
+} from "./chunk-2MXEVL75.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-JVRPJ7D4.js";
+} from "./chunk-EKQMQQ3U.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-YM3LR4LS.js";
+} from "./chunk-SSSXWIBP.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -338,7 +342,7 @@ import {
 } from "./chunk-OIF36KGD.js";
 import {
   parseQmdExplain
-} from "./chunk-PYWNNF2I.js";
+} from "./chunk-QRSKPI62.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -357,7 +361,7 @@ import {
 } from "./chunk-Y56J7CXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-Y2RIIF6H.js";
+} from "./chunk-Z6UDTNY6.js";
 import {
   ALL_CATEGORY_DIRS,
   ContentHashIndex,
@@ -368,7 +372,7 @@ import {
   normalizeEntityName,
   parseEntityFile,
   stripAttributesSuffix
-} from "./chunk-6CVI6BP6.js";
+} from "./chunk-NXCK7DO7.js";
 import {
   isValidTranscriptDate,
   loadSpeakerRegistry,
@@ -383,11 +387,14 @@ import {
 } from "./chunk-J6A3CX5N.js";
 import {
   confidenceTier
-} from "./chunk-NE2JBMLN.js";
+} from "./chunk-AZBV4RRY.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus
 } from "./chunk-RULE4VG5.js";
+import {
+  displayErrorDetail
+} from "./chunk-6KYMPV2O.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -438,17 +445,17 @@ import {
 } from "./chunk-AC5LO7IU.js";
 
 // src/orchestrator.ts
-import path3 from "path";
+import path4 from "path";
 import os from "os";
-import { createHash, randomBytes } from "crypto";
+import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
-  mkdir as mkdir3,
-  readdir as readdir2,
-  readFile as readFile3,
-  stat as stat2,
+  mkdir as mkdir4,
+  readdir as readdir3,
+  readFile as readFile4,
+  stat as stat3,
   unlink as unlink2,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "fs/promises";
 
 // src/procedural/procedure-recall.ts
@@ -2051,9 +2058,9 @@ var NamespaceCatalog = class {
     }
     if (await this.hasSymlinkedAncestor(candidate)) return false;
     try {
-      const stat3 = await lstat(candidate);
-      if (stat3.isSymbolicLink()) return false;
-      if (!stat3.isDirectory()) return false;
+      const stat4 = await lstat(candidate);
+      if (stat4.isSymbolicLink()) return false;
+      if (!stat4.isDirectory()) return false;
     } catch {
       return this.isNearestExistingAncestorContained(candidate, memoryReal);
     }
@@ -2114,8 +2121,8 @@ var NamespaceCatalog = class {
       }
       if (!(isPathInside(memoryReal, real) || real === memoryReal)) return false;
       try {
-        const stat3 = await lstat(real);
-        return stat3.isDirectory();
+        const stat4 = await lstat(real);
+        return stat4.isDirectory();
       } catch {
         return false;
       }
@@ -2279,14 +2286,14 @@ var NamespaceCatalog = class {
     if (normalizeNamespaceIdentity(namespace) !== this.defaultNamespaceIdentity && path2.resolve(root) === path2.resolve(this.memoryDir)) {
       return false;
     }
-    let stat3;
+    let stat4;
     try {
-      stat3 = await lstat(root);
+      stat4 = await lstat(root);
     } catch {
       return false;
     }
-    if (stat3.isSymbolicLink()) return false;
-    if (!stat3.isDirectory()) return false;
+    if (stat4.isSymbolicLink()) return false;
+    if (!stat4.isDirectory()) return false;
     try {
       const real = await realpath(root);
       if (memoryReal && !isPathInside(memoryReal, real)) return false;
@@ -2463,18 +2470,18 @@ var NamespaceCatalog = class {
     for (const entry of entries) {
       const token = entry.name;
       const fullPath = path2.join(namespacesDir, token);
-      let stat3;
+      let stat4;
       try {
-        stat3 = await lstat(fullPath);
+        stat4 = await lstat(fullPath);
       } catch (err) {
         skipped.push({ token, reason: "error", detail: err instanceof Error ? err.message : String(err) });
         continue;
       }
-      if (stat3.isSymbolicLink()) {
+      if (stat4.isSymbolicLink()) {
         skipped.push({ token, reason: "symlink", detail: fullPath });
         continue;
       }
-      if (!stat3.isDirectory()) continue;
+      if (!stat4.isDirectory()) continue;
       try {
         const real = await realpath(fullPath);
         if (memoryReal && !isPathInside(memoryReal, real)) {
@@ -2865,6 +2872,611 @@ function isPathInside(root, child) {
   return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
 }
 
+// src/maintenance/namespace-planner.ts
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { lstat as lstat2, mkdir as mkdir3, open as open2, readFile as readFile3, readdir as readdir2, rename as rename2, rm, rmdir, utimes as utimes2, writeFile as writeFile3 } from "fs/promises";
+import path3 from "path";
+var DEFAULT_MAX_NAMESPACES_PER_CYCLE = 20;
+var DEFAULT_LOCK_STALE_MS = 10 * 6e4;
+var LOCK_BASE = "maintenance-locks";
+var STATUS_BASE = "namespace-maintenance-status";
+var namespaceMaintenanceFs = { open: open2, rm };
+function configuredNamespaces(config) {
+  return Array.from(
+    new Set(
+      [config.defaultNamespace, config.sharedNamespace, ...config.namespacePolicies.map((policy) => policy.name)].map((value) => value.trim()).filter(Boolean)
+    )
+  );
+}
+function inferConfiguredKind(config, namespace) {
+  if (namespace === config.defaultNamespace.trim()) return "default";
+  if (namespace === config.sharedNamespace.trim()) return "shared";
+  return "explicit";
+}
+function maxNamespacesPerCycle(config) {
+  return Math.max(
+    1,
+    Math.floor(
+      typeof config.maintenanceMaxNamespacesPerCycle === "number" && Number.isFinite(config.maintenanceMaxNamespacesPerCycle) ? config.maintenanceMaxNamespacesPerCycle : DEFAULT_MAX_NAMESPACES_PER_CYCLE
+    )
+  );
+}
+function namespaceKindAllowed(config, kind) {
+  switch (kind) {
+    case "branch":
+      return config.maintenanceIncludeBranchNamespaces === true;
+    case "project":
+      return config.maintenanceIncludeProjectNamespaces !== false;
+    case "team-project":
+      return config.maintenanceIncludeTeamProjectNamespaces !== false;
+    default:
+      return true;
+  }
+}
+function disabledReasonForKind(kind) {
+  if (kind === "branch") return "branch_disabled";
+  if (kind === "project") return "project_disabled";
+  if (kind === "team-project") return "team_project_disabled";
+  return "fanout_disabled";
+}
+async function catalogRootIsLive(config, record) {
+  if (typeof record.storageDir !== "string" || record.storageDir.length === 0) {
+    return false;
+  }
+  try {
+    const liveRoot = await resolveNamespaceStorageRoot(config, record.namespace);
+    if (path3.resolve(liveRoot) !== path3.resolve(record.storageDir)) return false;
+    return hasMemoryData(liveRoot);
+  } catch {
+    return false;
+  }
+}
+function candidateSortKey(candidate) {
+  const write = candidate.lastWriteAt ?? "";
+  return `${write}\0${candidate.namespace}`;
+}
+function candidatePriority(candidate) {
+  if (candidate.kind === "default") return 0;
+  if (candidate.kind === "shared") return 1;
+  if (candidate.source === "configured") return 2;
+  if (candidate.kind === "team-project") return 3;
+  if (candidate.kind === "project") return 4;
+  if (candidate.kind === "self") return 5;
+  if (candidate.kind === "legacy") return 6;
+  if (candidate.kind === "branch") return 8;
+  return 7;
+}
+function sortCandidates(a, b) {
+  const priority = candidatePriority(a) - candidatePriority(b);
+  if (priority !== 0) return priority;
+  const am = Date.parse(a.lastMaintenanceAt ?? "");
+  const bm = Date.parse(b.lastMaintenanceAt ?? "");
+  const aMaintained = Number.isFinite(am);
+  const bMaintained = Number.isFinite(bm);
+  if (aMaintained && bMaintained && am !== bm) return am - bm;
+  if (aMaintained !== bMaintained) return aMaintained ? 1 : -1;
+  const aw = Date.parse(a.lastWriteAt ?? "");
+  const bw = Date.parse(b.lastWriteAt ?? "");
+  const aValid = Number.isFinite(aw);
+  const bValid = Number.isFinite(bw);
+  if (aValid && bValid && aw !== bw) return bw - aw;
+  if (aValid !== bValid) return aValid ? -1 : 1;
+  const byKey = candidateSortKey(a).localeCompare(candidateSortKey(b));
+  if (byKey !== 0) return byKey;
+  return a.namespace.localeCompare(b.namespace);
+}
+async function planNamespaceMaintenance(config, options) {
+  const generatedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const configured = configuredNamespaces(config);
+  const byNamespace = /* @__PURE__ */ new Map();
+  const skipped = [];
+  for (const namespace of configured) {
+    const kind = inferConfiguredKind(config, namespace);
+    byNamespace.set(namespace, {
+      namespace,
+      kind,
+      source: "configured"
+    });
+  }
+  if (config.namespacesEnabled && config.maintenanceNamespaceFanoutEnabled !== false) {
+    const configuredSet = new Set(configured);
+    try {
+      const records = options.catalog?.enabled ? await options.catalog.listNamespaces() : [];
+      for (const record of records) {
+        const namespace = record.namespace.trim();
+        if (!namespace) continue;
+        const isConfigured = configuredSet.has(namespace);
+        const kind = isConfigured ? inferConfiguredKind(config, namespace) : record.kind;
+        if (!namespaceKindAllowed(config, kind)) {
+          skipped.push({
+            namespace,
+            kind,
+            reason: disabledReasonForKind(kind)
+          });
+          continue;
+        }
+        if (!isConfigured && !await catalogRootIsLive(config, record)) {
+          skipped.push({
+            namespace,
+            kind,
+            reason: "unsafe_or_stale_root"
+          });
+          continue;
+        }
+        byNamespace.set(namespace, {
+          namespace,
+          kind,
+          storageDir: record.storageDir,
+          source: isConfigured ? "configured" : "catalog",
+          lastWriteAt: record.lastWriteAt,
+          lastMaintenanceAt: record.lastMaintenanceAt?.[options.jobName]
+        });
+      }
+    } catch (error) {
+      skipped.push({
+        namespace: "*",
+        reason: "catalog_read_failed",
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    }
+  } else if (config.namespacesEnabled) {
+    skipped.push({
+      namespace: "*",
+      reason: "fanout_disabled"
+    });
+  }
+  if (options.budgetMode !== "unbounded") {
+    const latestStatusAtByNamespace = await readLatestStatusAtByNamespace(config, options.jobName);
+    for (const candidate of byNamespace.values()) {
+      if (!candidate.lastMaintenanceAt) {
+        candidate.lastMaintenanceAt = latestStatusAtByNamespace.get(candidate.namespace);
+      }
+    }
+  }
+  const candidates = [...byNamespace.values()].filter((candidate) => namespaceKindAllowed(config, candidate.kind)).sort(sortCandidates);
+  const max = maxNamespacesPerCycle(config);
+  const applyCycleBudget = options.budgetMode !== "unbounded";
+  const selected = applyCycleBudget ? candidates.slice(0, max) : candidates;
+  if (applyCycleBudget) {
+    for (const candidate of candidates.slice(max)) {
+      skipped.push({
+        namespace: candidate.namespace,
+        kind: candidate.kind,
+        reason: "budget_exhausted"
+      });
+    }
+  }
+  return {
+    jobName: options.jobName,
+    generatedAt,
+    namespaces: selected,
+    skipped,
+    budget: {
+      maxNamespacesPerCycle: max,
+      selected: selected.length
+    }
+  };
+}
+function stablePathSegment(value) {
+  const sanitized = value.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 128) || "unnamed";
+  if (sanitized.length <= 128 && sanitized === value) return sanitized;
+  return `${sanitized.slice(0, 80)}-${createHash("sha256").update(value).digest("hex").slice(0, 16)}`;
+}
+function namespacePathSegment(namespace) {
+  const token = namespaceIdentityToken(namespace);
+  if (token.length <= 160) return token;
+  return `ns-${createHash("sha256").update(namespace).digest("hex")}`;
+}
+function lockPath(config, jobName, namespace) {
+  return path3.join(
+    config.memoryDir,
+    "state",
+    LOCK_BASE,
+    stablePathSegment(jobName),
+    `${namespacePathSegment(namespace)}.lock`
+  );
+}
+function namespaceMaintenanceLockStaleMs(config) {
+  if (typeof config.maintenanceNamespaceLockStaleMs === "number" && Number.isFinite(config.maintenanceNamespaceLockStaleMs) && config.maintenanceNamespaceLockStaleMs > 0) {
+    return Math.floor(config.maintenanceNamespaceLockStaleMs);
+  }
+  return DEFAULT_LOCK_STALE_MS;
+}
+function namespaceMaintenanceLockHeartbeatMs(config) {
+  const staleMs = namespaceMaintenanceLockStaleMs(config);
+  return Math.max(1, Math.min(3e4, Math.floor(staleMs / 3) || 1));
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+async function withNamespaceMaintenanceLockHeartbeat(config, locks, task) {
+  const activeLocks = Array.isArray(locks) ? locks : [locks];
+  const interval = setInterval(() => {
+    for (const lock of activeLocks) {
+      void lock.touch().catch(() => void 0);
+    }
+  }, namespaceMaintenanceLockHeartbeatMs(config));
+  interval.unref?.();
+  try {
+    return await task();
+  } finally {
+    clearInterval(interval);
+  }
+}
+async function removeStaleLockDirectory(filePath) {
+  let entries;
+  try {
+    entries = await readdir2(filePath, { withFileTypes: true });
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return;
+    throw error;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    await namespaceMaintenanceFs.rm(path3.join(filePath, entry.name), { force: true });
+  }
+  try {
+    await rmdir(filePath);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return;
+    throw error;
+  }
+}
+async function tryAcquireNamespaceMaintenanceLock(config, jobName, namespace) {
+  const filePath = lockPath(config, jobName, namespace);
+  await mkdir3(path3.dirname(filePath), { recursive: true });
+  try {
+    const lockId = randomUUID2();
+    await mkdir3(filePath);
+    const ownerPath = path3.join(filePath, `${lockId}.json`);
+    let handle;
+    try {
+      handle = await namespaceMaintenanceFs.open(ownerPath, "wx");
+      await handle.writeFile(
+        `${JSON.stringify({
+          lockId,
+          pid: process.pid,
+          jobName,
+          namespace,
+          acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
+        })}
+`,
+        "utf8"
+      );
+      await handle.close();
+    } catch (setupError) {
+      await handle?.close().catch(() => void 0);
+      await namespaceMaintenanceFs.rm(ownerPath, { force: true }).catch(() => void 0);
+      await rmdir(filePath).catch(() => void 0);
+      throw setupError;
+    }
+    return {
+      path: filePath,
+      async touch() {
+        try {
+          const parsed = JSON.parse(await readFile3(ownerPath, "utf8"));
+          if (parsed.lockId === lockId) {
+            const now = /* @__PURE__ */ new Date();
+            await utimes2(ownerPath, now, now);
+            await utimes2(filePath, now, now);
+          }
+        } catch {
+        }
+      },
+      async release() {
+        try {
+          const parsed = JSON.parse(await readFile3(ownerPath, "utf8"));
+          if (parsed.lockId === lockId) {
+            await namespaceMaintenanceFs.rm(ownerPath, { force: true });
+            await rmdir(filePath).catch(() => void 0);
+          }
+        } catch {
+        }
+      }
+    };
+  } catch (error) {
+    if (errorCode(error) === "EEXIST") {
+      const staleMs = namespaceMaintenanceLockStaleMs(config);
+      try {
+        const s = await lstat2(filePath);
+        if (s.isSymbolicLink()) {
+          return null;
+        }
+        if ((s.isFile() || s.isDirectory()) && Date.now() - s.mtimeMs > staleMs) {
+          try {
+            if (s.isDirectory()) {
+              await removeStaleLockDirectory(filePath);
+            } else {
+              await namespaceMaintenanceFs.rm(filePath, { force: true });
+            }
+          } catch (removeError) {
+            if (errorCode(removeError) === "ENOENT") {
+              return tryAcquireNamespaceMaintenanceLock(config, jobName, namespace);
+            }
+            if (errorCode(removeError) === "ENOTEMPTY") {
+              return null;
+            }
+            throw removeError;
+          }
+          return tryAcquireNamespaceMaintenanceLock(config, jobName, namespace);
+        }
+      } catch (statError) {
+        if (errorCode(statError) === "ENOENT") {
+          return tryAcquireNamespaceMaintenanceLock(config, jobName, namespace);
+        }
+        throw statError;
+      }
+      return null;
+    }
+    throw error;
+  }
+}
+function statusBasePath(config) {
+  return path3.join(config.memoryDir, "state", STATUS_BASE);
+}
+function statusPath(config, jobName, namespace) {
+  return path3.join(statusBasePath(config), stablePathSegment(jobName), `${namespacePathSegment(namespace)}.json`);
+}
+function lastRanStatusPath(config, jobName, namespace) {
+  return path3.join(statusBasePath(config), stablePathSegment(jobName), `${namespacePathSegment(namespace)}.last-ran.json`);
+}
+function parseStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const v = value;
+  if (typeof v.namespace === "string" && typeof v.jobName === "string" && (v.state === "ran" || v.state === "skipped" || v.state === "failed") && typeof v.startedAt === "string" && typeof v.completedAt === "string") {
+    return v;
+  }
+  return null;
+}
+async function readLatestStatusAtByNamespace(config, jobName) {
+  const latest = /* @__PURE__ */ new Map();
+  const latestMs = /* @__PURE__ */ new Map();
+  for (const status of [...await readStatusFiles(config), ...await readLastRanStatusFiles(config)]) {
+    if (status.state !== "ran") continue;
+    if (status.jobName !== jobName) continue;
+    const completedAtMs = Date.parse(status.completedAt);
+    if (!Number.isFinite(completedAtMs)) continue;
+    const previousMs = latestMs.get(status.namespace);
+    if (previousMs !== void 0 && previousMs >= completedAtMs) continue;
+    latestMs.set(status.namespace, completedAtMs);
+    latest.set(status.namespace, status.completedAt);
+  }
+  return latest;
+}
+async function readStatusFile(filePath) {
+  try {
+    const parsed = JSON.parse(await readFile3(filePath, "utf8"));
+    return parseStatus(parsed);
+  } catch {
+    return null;
+  }
+}
+async function readStatusFiles(config) {
+  if (typeof config.memoryDir !== "string" || config.memoryDir.length === 0) {
+    return [];
+  }
+  const root = statusBasePath(config);
+  const statuses = [];
+  let jobDirs;
+  try {
+    jobDirs = await readdir2(root, { withFileTypes: true });
+  } catch {
+    return statuses;
+  }
+  for (const jobDir of jobDirs) {
+    if (!jobDir.isDirectory()) continue;
+    let files;
+    try {
+      files = await readdir2(path3.join(root, jobDir.name), { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.isFile() || !file.name.endsWith(".json")) continue;
+      if (file.name.endsWith(".last-ran.json")) continue;
+      const status = await readStatusFile(path3.join(root, jobDir.name, file.name));
+      if (status) statuses.push(status);
+    }
+  }
+  return statuses;
+}
+async function readLastRanStatusFiles(config) {
+  if (typeof config.memoryDir !== "string" || config.memoryDir.length === 0) {
+    return [];
+  }
+  const root = statusBasePath(config);
+  const statuses = [];
+  let jobDirs;
+  try {
+    jobDirs = await readdir2(root, { withFileTypes: true });
+  } catch {
+    return statuses;
+  }
+  for (const jobDir of jobDirs) {
+    if (!jobDir.isDirectory()) continue;
+    let files;
+    try {
+      files = await readdir2(path3.join(root, jobDir.name), { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.isFile() || !file.name.endsWith(".last-ran.json")) continue;
+      const status = await readStatusFile(path3.join(root, jobDir.name, file.name));
+      if (status) statuses.push(status);
+    }
+  }
+  return statuses;
+}
+async function writeStatusPayload(target, status) {
+  const dir = path3.dirname(target);
+  await mkdir3(dir, { recursive: true });
+  const temp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  const payload = {
+    version: 1,
+    ...status
+  };
+  await writeFile3(temp, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  await rename2(temp, target);
+}
+async function writeStatusFile(config, status) {
+  await writeStatusPayload(statusPath(config, status.jobName, status.namespace), status);
+  if (status.state === "ran") {
+    await writeStatusPayload(lastRanStatusPath(config, status.jobName, status.namespace), status);
+  }
+}
+async function recordNamespaceMaintenanceStatusSafely(config, status) {
+  try {
+    await writeStatusFile(config, status);
+  } catch {
+  }
+}
+function maintenanceErrorDetail(error) {
+  return displayErrorDetail(error) || "Error";
+}
+async function runNamespaceMaintenanceBatchPlan(config, plan, runner, catalog, options = {}) {
+  const statuses = [];
+  for (const skipped of plan.skipped) {
+    if (skipped.namespace === "*") continue;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const status = {
+      namespace: skipped.namespace,
+      jobName: plan.jobName,
+      state: "skipped",
+      reason: skipped.reason,
+      startedAt: now,
+      completedAt: now
+    };
+    statuses.push(status);
+    await recordNamespaceMaintenanceStatusSafely(config, status);
+  }
+  const acquired = [];
+  try {
+    for (const candidate of plan.namespaces) {
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const lock = await tryAcquireNamespaceMaintenanceLock(config, plan.jobName, candidate.namespace);
+      if (!lock) {
+        const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const status = {
+          namespace: candidate.namespace,
+          jobName: plan.jobName,
+          state: "skipped",
+          reason: "lock_held",
+          startedAt,
+          completedAt
+        };
+        statuses.push(status);
+        await recordNamespaceMaintenanceStatusSafely(config, status);
+        continue;
+      }
+      acquired.push({ candidate, lock, startedAt });
+    }
+  } catch (error) {
+    await Promise.all(acquired.map(({ lock }) => lock.release().catch(() => void 0)));
+    throw error;
+  }
+  if (options.requireAllLocks && acquired.length > 0 && acquired.length < plan.namespaces.length) {
+    for (const { candidate, startedAt } of acquired) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const status = {
+        namespace: candidate.namespace,
+        jobName: plan.jobName,
+        state: "skipped",
+        reason: "batch_lock_incomplete",
+        startedAt,
+        completedAt
+      };
+      statuses.push(status);
+      await recordNamespaceMaintenanceStatusSafely(config, status);
+    }
+    await Promise.all(acquired.map(({ lock }) => lock.release().catch(() => void 0)));
+    return {
+      jobName: plan.jobName,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ran: statuses.filter((s) => s.state === "ran").length,
+      skipped: statuses.filter((s) => s.state === "skipped").length,
+      failed: statuses.filter((s) => s.state === "failed").length,
+      statuses
+    };
+  }
+  if (acquired.length === 0) {
+    return {
+      jobName: plan.jobName,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ran: statuses.filter((s) => s.state === "ran").length,
+      skipped: statuses.filter((s) => s.state === "skipped").length,
+      failed: statuses.filter((s) => s.state === "failed").length,
+      statuses
+    };
+  }
+  try {
+    const result = await withNamespaceMaintenanceLockHeartbeat(
+      config,
+      acquired.map(({ lock }) => lock),
+      () => runner(acquired.map(({ candidate }) => candidate))
+    );
+    for (const { candidate, startedAt } of acquired) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const status = {
+        namespace: candidate.namespace,
+        jobName: plan.jobName,
+        state: "ran",
+        startedAt,
+        completedAt,
+        itemCount: itemCountForNamespace(result, candidate.namespace)
+      };
+      statuses.push(status);
+      await recordNamespaceMaintenanceStatusSafely(config, status);
+      try {
+        await catalog?.markMaintenance(candidate.namespace, plan.jobName, new Date(completedAt));
+      } catch {
+      }
+    }
+  } catch (error) {
+    const skipReason = options.skipReasonForError?.(error);
+    for (const { candidate, startedAt } of acquired) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const status = skipReason ? {
+        namespace: candidate.namespace,
+        jobName: plan.jobName,
+        state: "skipped",
+        reason: skipReason,
+        startedAt,
+        completedAt
+      } : {
+        namespace: candidate.namespace,
+        jobName: plan.jobName,
+        state: "failed",
+        reason: "job_failed",
+        startedAt,
+        completedAt,
+        error: maintenanceErrorDetail(error)
+      };
+      statuses.push(status);
+      await recordNamespaceMaintenanceStatusSafely(config, status);
+    }
+  } finally {
+    await Promise.all(acquired.map(({ lock }) => lock.release().catch(() => void 0)));
+  }
+  return {
+    jobName: plan.jobName,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ran: statuses.filter((s) => s.state === "ran").length,
+    skipped: statuses.filter((s) => s.state === "skipped").length,
+    failed: statuses.filter((s) => s.state === "failed").length,
+    statuses
+  };
+}
+function itemCountForNamespace(result, namespace) {
+  const itemCounts = result?.itemCounts;
+  if (itemCounts instanceof Map) return itemCounts.get(namespace);
+  if (itemCounts && Object.prototype.hasOwnProperty.call(itemCounts, namespace)) {
+    return itemCounts[namespace];
+  }
+  return result?.itemCount;
+}
+
 // src/orchestrator.ts
 var BulkImportBatchPartialFailureError = class extends Error {
   partialResult;
@@ -2926,7 +3538,7 @@ function flattenStructuredSectionEvidence(sections) {
   );
 }
 function fingerprintEntitySynthesisEvidence(entity) {
-  const fingerprint = createHash("sha256");
+  const fingerprint = createHash2("sha256");
   const timelineEntries = entity.timeline.map((entry) => [
     entry.timestamp,
     entry.source ?? "",
@@ -2976,7 +3588,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;
@@ -2989,9 +3601,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);
     }
@@ -2999,12 +3611,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);
@@ -3121,11 +3733,11 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path3.join(os.homedir(), ".openclaw", "workspace");
+  return path4.join(os.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) {
@@ -3426,11 +4038,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;
@@ -3572,7 +4184,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;
 }
@@ -3580,7 +4192,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,
@@ -3600,16 +4212,20 @@ 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 = options.category === "procedure" ? "procedures" : options.category === "reasoning_trace" ? "reasoning-traces" : "facts";
   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`);
+}
+function qmdMaintenanceSkipReasonForError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /^QMD (?:update|embed) skipped by .*min-interval gate$/.test(message) ? "throttled" : null;
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -3716,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)
@@ -3737,6 +4354,7 @@ var Orchestrator = class _Orchestrator {
   qmdMaintenancePending = false;
   qmdMaintenanceInFlight = false;
   lastQmdEmbedAtMs = 0;
+  lastQmdEmbedAtMsByNamespace = /* @__PURE__ */ new Map();
   lastQmdReprobeAtMs = 0;
   tierMigrationInFlight = false;
   lastTierMigrationRunAtMs = 0;
@@ -4038,7 +4656,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();
@@ -4049,21 +4667,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;
@@ -4091,7 +4709,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 {
@@ -4128,7 +4746,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,
@@ -4145,57 +4763,27 @@ var Orchestrator = class _Orchestrator {
     }
   }
   /**
-   * Namespaces that QMD maintenance (update/embed) must cover: the CONFIGURED set
-   * PLUS every dynamic namespace recorded in the catalog (NGnei, codex P2). An
-   * extraction that writes to a coding-scoped/dynamic namespace (not in
-   * defaultNamespace/sharedNamespace/namespacePolicies) is only made discoverable
-   * via the catalog; if maintenance embeds only `configuredNamespaces()`, that
-   * namespace's QMD collection is never updated/embedded after writes and
-   * recall/search stays stale or empty until it is manually configured. We union in
-   * the catalog's namespaces so maintenance keeps dynamic namespaces fresh.
-   * `updateNamespaces`/`embedNamespaces` already trim, dedup, and skip
-   * unavailable/missing collections, so extra names are filtered safely. A catalog
-   * read failure must never break maintenance — fall back to the configured set.
+   * Shared namespace maintenance planner (issue #1500). This extends the
+   * #1499 catalog-union QMD helper into a reusable contract: configured
+   * namespaces are always considered, dynamic catalog namespaces are admitted
+   * only when their live router root still matches real memory data, and branch
+   * namespaces are opt-in. Recurring jobs use the per-cycle budget; startup and
+   * recovery discovery paths use the same safety filters without that cycle
+   * budget so every live namespace is ensured/synced.
    */
-  async maintenanceNamespaces() {
-    const configured = this.configuredNamespaces();
-    if (!this.namespaceCatalog.enabled) return configured;
-    const configuredSet = new Set(configured);
-    let cataloged = [];
-    try {
-      const records = await this.namespaceCatalog.listNamespaces();
-      const safeRecords = await Promise.all(
-        records.map(async (record) => {
-          const namespace = record.namespace.trim();
-          if (!namespace || configuredSet.has(namespace)) return null;
-          return await this.isCatalogedMaintenanceRootLive(record) ? namespace : null;
-        })
-      );
-      cataloged = safeRecords.filter(
-        (namespace) => namespace !== null
-      );
-    } catch {
-      cataloged = [];
-    }
-    return Array.from(
-      new Set(
-        [...configured, ...cataloged].map((value) => value.trim()).filter(Boolean)
-      )
-    );
+  async namespaceMaintenancePlan(jobName) {
+    return planNamespaceMaintenance(this.config, {
+      jobName,
+      catalog: this.namespaceCatalog
+    });
   }
-  async isCatalogedMaintenanceRootLive(record) {
-    if (typeof record.storageDir !== "string" || record.storageDir.length === 0) {
-      return false;
-    }
-    try {
-      const liveRoot = await resolveNamespaceStorageRoot(this.config, record.namespace);
-      if (path3.resolve(liveRoot) !== path3.resolve(record.storageDir)) {
-        return false;
-      }
-      return hasMemoryData(liveRoot);
-    } catch {
-      return false;
-    }
+  async maintenanceNamespaces(jobName = "qmd", budgetMode = "unbounded") {
+    const plan = await planNamespaceMaintenance(this.config, {
+      jobName,
+      catalog: this.namespaceCatalog,
+      budgetMode
+    });
+    return plan.namespaces.map((candidate) => candidate.namespace);
   }
   buildConfiguredQmdSearchOptions(queryText) {
     const intentHint = this.config.qmdIntentHintsEnabled ? buildQmdIntentHint(inferIntentFromText(queryText)) : void 0;
@@ -4210,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)
@@ -4266,12 +4857,63 @@ 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;
     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);
@@ -4316,7 +4958,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"
@@ -4373,7 +5015,7 @@ var Orchestrator = class _Orchestrator {
       this.modelRegistry
     );
     this.threading = new ThreadingManager(
-      path3.join(config.memoryDir, "threads"),
+      path4.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -4452,7 +5094,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;
@@ -4672,11 +5314,11 @@ var Orchestrator = class _Orchestrator {
       if (this.config.compactionResetEnabled) {
         try {
           const wsDir = this.config.workspaceDir || defaultWorkspaceDir();
-          const files = await readdir2(wsDir).catch(() => []);
+          const files = await readdir3(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path3.join(wsDir, f);
-            const s = await stat2(fp).catch(() => null);
+            const fp = path4.join(wsDir, f);
+            const s = await stat3(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink2(fp).catch(() => {
               });
@@ -4954,9 +5596,9 @@ var Orchestrator = class _Orchestrator {
           `wearables auto-sync started: every ${this.config.wearables.autoSyncIntervalMinutes}m over ${this.config.wearables.autoSyncDays}d (deep ${this.config.wearables.autoSyncDeepDays}d daily)`
         );
       } catch (err) {
-        const { displayErrorDetail } = await import("./runtime/better-sqlite.js");
+        const { displayErrorDetail: displayErrorDetail2 } = await import("./runtime/better-sqlite.js");
         log.warn(
-          `wearables auto-sync failed to start (non-fatal): ${displayErrorDetail(err)}`
+          `wearables auto-sync failed to start (non-fatal): ${displayErrorDetail2(err)}`
         );
       }
     }
@@ -5069,7 +5711,7 @@ var Orchestrator = class _Orchestrator {
    */
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path4.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug(
@@ -5122,7 +5764,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path4.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -5144,7 +5786,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path4.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -5164,7 +5806,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path4.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -5184,7 +5826,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path4.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
@@ -5246,7 +5888,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path4.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
@@ -5303,15 +5945,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 readFile3(abs, "utf-8");
+          const raw = await readFile4(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,
@@ -5319,7 +5961,7 @@ ${doc.content}` : doc.content,
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile3(abs, newContent, "utf-8");
+            await writeFile4(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -5336,8 +5978,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 mkdir3(path3.dirname(fp), { recursive: true });
+        const fp = path4.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir4(path4.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -5346,11 +5988,11 @@ ${doc.content}` : doc.content,
 ` + warnings.map((w) => `- ${w.message}`).join("\n") + "\n";
         let existing = "";
         try {
-          existing = await readFile3(fp, "utf-8");
+          existing = await readFile4(fp, "utf-8");
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile3(fp, existing + block, "utf-8");
+        await writeFile4(fp, existing + block, "utf-8");
       }
     }
   }
@@ -5545,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) {
@@ -5590,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}`
         )
@@ -5820,18 +6457,18 @@ ${evidenceText}`
     const now = options.now instanceof Date && Number.isFinite(options.now.getTime()) ? options.now : /* @__PURE__ */ new Date();
     const targetLocalDate = formatDateInTimeZone(now, timeZone);
     const datesToScan = utcDateKeysForLocalDay(now, timeZone);
-    const factsBaseDir = path3.join(storage.dir, "facts");
+    const factsBaseDir = path4.join(storage.dir, "facts");
     const MAX_CHARS = 1e5;
     const facts = [];
     for (const date of datesToScan) {
-      const factsDir = path3.join(factsBaseDir, date);
+      const factsDir = path4.join(factsBaseDir, date);
       try {
-        const entries = await readdir2(factsDir, { withFileTypes: true });
+        const entries = await readdir3(factsDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.name.endsWith(".md")) continue;
-          const fullPath = path3.join(factsDir, entry.name);
+          const fullPath = path4.join(factsDir, entry.name);
           try {
-            const raw = await readFile3(fullPath, "utf-8");
+            const raw = await readFile4(fullPath, "utf-8");
             const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
             if (!fmMatch) continue;
             const fmBlock = fmMatch[1];
@@ -5850,7 +6487,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,
@@ -5872,15 +6509,15 @@ ${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 readdir2(hourlyBaseDir, { withFileTypes: true });
+      const sessionKeys = await readdir3(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 readFile3(summaryFile, "utf-8");
+            const raw = await readFile4(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
               raw,
               date,
@@ -5982,13 +6619,13 @@ ${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"
     );
     try {
-      const raw = await readFile3(snapshotPath, "utf-8");
+      const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -6021,9 +6658,9 @@ ${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 readFile3(snapshotPath, "utf-8");
+      const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       const graphDecision = parsed.graphDecision && typeof parsed.graphDecision === "object" ? parsed.graphDecision : void 0;
@@ -6054,13 +6691,13 @@ ${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"
     );
     try {
-      const raw = await readFile3(snapshotPath, "utf-8");
+      const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -6204,10 +6841,10 @@ ${r.snippet.trim()}
   }
   async countConversationChunkDocs(dir) {
     try {
-      const entries = await readdir2(dir, { withFileTypes: true });
+      const entries = await readdir3(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;
@@ -6499,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}`);
@@ -6554,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(
@@ -6933,7 +7586,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,
@@ -7106,7 +7759,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;
       }
@@ -7131,7 +7784,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);
@@ -7174,7 +7827,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(
@@ -7190,7 +7843,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;
@@ -7215,7 +7868,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,
@@ -7236,12 +7889,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 mkdir3(path3.dirname(snapshotPath), { recursive: true });
+      await mkdir4(path4.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -7253,7 +7906,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,
@@ -7268,20 +7921,20 @@ ${r.snippet.trim()}
         finalResults: (options.finalResults ?? []).slice(0, 64),
         shadowComparison: options.shadowComparison
       };
-      await writeFile3(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile4(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 mkdir3(path3.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir4(path4.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -7292,13 +7945,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 mkdir3(path3.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir4(path4.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -7312,9 +7965,9 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path3.join(stateDir, "last_intent.json");
-      await mkdir3(path3.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      const snapshotPath = path4.join(stateDir, "last_intent.json");
+      await mkdir4(path4.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -7325,24 +7978,24 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!this.config.namespacesEnabled) {
-      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
     );
     try {
-      const candidateStat = await stat2(candidate);
+      const candidateStat = await stat3(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) => ({
@@ -7584,8 +8237,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,
@@ -7594,7 +8247,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";
@@ -7697,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
@@ -7712,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)
@@ -7724,7 +8395,7 @@ ${r.snippet.trim()}
       } else {
         lcmReadNamespaces = [this.config.defaultNamespace];
       }
-      const lcmReadSessionIds = lcmReadSessionIdsForNamespaces(
+      const lcmReadSessionIds = scopeProfilePlan && !sessionKey ? [] : lcmReadSessionIdsForNamespaces(
         lcmReadNamespaces,
         sessionKey,
         this.config.defaultNamespace
@@ -7752,7 +8423,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))
@@ -7897,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);
@@ -7909,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(),
@@ -8133,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",
@@ -8506,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",
@@ -8560,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(
@@ -8623,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(
@@ -8682,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",
@@ -8862,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 {
@@ -9070,16 +10011,16 @@ ${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 stat2(signalPath).catch(() => null);
+          const signalStat = await stat3(signalPath).catch(() => null);
           if (!signalStat) return null;
           const signalAge = Date.now() - signalStat.mtimeMs;
-          const signalData = JSON.parse(await readFile3(signalPath, "utf-8"));
+          const signalData = JSON.parse(await readFile4(signalPath, "utf-8"));
           if (signalData.sessionKey !== effectiveSessionKey) {
             log.debug(
               `recall: compaction signal is for ${signalData.sessionKey}, not ${effectiveSessionKey} \u2014 skipping`
@@ -9099,7 +10040,7 @@ ${formatted}`;
 
 `;
           try {
-            const bootContent = await readFile3(bootPath, "utf-8");
+            const bootContent = await readFile4(bootPath, "utf-8");
             section += "### BOOT.md (working state before compaction)\n\n";
             section += bootContent + "\n";
           } catch {
@@ -9352,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();
@@ -11204,7 +12165,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,
@@ -11461,7 +12422,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 = {}) {
@@ -11609,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)
     );
@@ -11737,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();
@@ -11951,7 +12947,7 @@ ${normalized}`).digest("hex");
     );
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path3.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path4.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -12095,13 +13091,61 @@ ${normalized}`).digest("hex");
     this.qmdMaintenancePending = false;
     try {
       if (this.config.namespacesEnabled) {
-        const maintenanceNamespaces = await this.maintenanceNamespaces();
-        await this.namespaceSearchRouter.updateNamespaces(maintenanceNamespaces);
+        const plan = await this.namespaceMaintenancePlan("qmd");
         const now = Date.now();
-        if (this.config.qmdAutoEmbedEnabled && now - this.lastQmdEmbedAtMs >= this.config.qmdEmbedMinIntervalMs) {
-          await this.namespaceSearchRouter.embedNamespaces(maintenanceNamespaces);
+        const lastEmbedAtByNamespace = this.lastQmdEmbedAtMsByNamespace ?? (this.lastQmdEmbedAtMsByNamespace = /* @__PURE__ */ new Map());
+        const dueEmbedNamespaces = (namespaces) => {
+          if (!this.config.qmdAutoEmbedEnabled) return [];
+          return namespaces.filter(
+            (namespace) => now - (lastEmbedAtByNamespace.get(namespace) ?? 0) >= this.config.qmdEmbedMinIntervalMs
+          );
+        };
+        const markEmbedded = (namespaces) => {
+          if (namespaces.length === 0) return;
+          for (const namespace of namespaces) {
+            lastEmbedAtByNamespace.set(namespace, now);
+          }
           this.lastQmdEmbedAtMs = now;
-        }
+        };
+        await runNamespaceMaintenanceBatchPlan(
+          this.config,
+          plan,
+          async (candidates) => {
+            const namespaces = candidates.map((candidate) => candidate.namespace);
+            const embedNamespaces = dueEmbedNamespaces(namespaces);
+            let result;
+            try {
+              result = await this.namespaceSearchRouter.updateNamespacesDetailed(
+                namespaces,
+                void 0,
+                { strict: true }
+              );
+            } catch (error) {
+              if (embedNamespaces.length > 0 && qmdMaintenanceSkipReasonForError(error) === "throttled") {
+                await this.namespaceSearchRouter.embedNamespaces(embedNamespaces, { strict: true });
+                markEmbedded(embedNamespaces);
+              }
+              throw error;
+            }
+            if (result.backendCount <= 0) {
+              throw new Error("no eligible QMD backend for selected namespaces");
+            }
+            if (result.eligibleNamespaces.length !== namespaces.length) {
+              const eligible = new Set(result.eligibleNamespaces);
+              const missing = namespaces.filter((namespace) => !eligible.has(namespace));
+              throw new Error(`QMD backend ineligible for selected namespaces (${missing.length})`);
+            }
+            if (embedNamespaces.length > 0) {
+              await this.namespaceSearchRouter.embedNamespaces(embedNamespaces, { strict: true });
+              markEmbedded(embedNamespaces);
+            }
+            return { itemCount: result.backendCount };
+          },
+          this.namespaceCatalog,
+          {
+            skipReasonForError: qmdMaintenanceSkipReasonForError
+          }
+        );
       } else {
         await this.qmd.update();
         const now = Date.now();
@@ -12117,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 ? {
@@ -12171,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,
@@ -12273,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) {
@@ -12551,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
@@ -12565,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;
@@ -12834,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}`;
@@ -13038,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);
@@ -13141,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
@@ -13196,7 +14368,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);
           }
         }
@@ -13512,14 +14684,14 @@ ${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"
         );
         let shouldRun = true;
         try {
-          const stateRaw = await readFile3(stateFilePath, "utf-8");
+          const stateRaw = await readFile4(stateFilePath, "utf-8");
           const stateData = JSON.parse(stateRaw);
           if (stateData.lastRunAt) {
             const lastRunMs = new Date(stateData.lastRunAt).getTime();
@@ -13560,9 +14732,9 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path3.join(this.config.memoryDir, "state");
-            await mkdir3(stateDir, { recursive: true });
-            await writeFile3(
+            const stateDir = path4.join(this.config.memoryDir, "state");
+            await mkdir4(stateDir, { recursive: true });
+            await writeFile4(
               stateFilePath,
               JSON.stringify({ lastRunAt: (/* @__PURE__ */ new Date()).toISOString() }),
               "utf-8"
@@ -13761,7 +14933,7 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       }
     });
     const content = renderCompressionGuidelinesMarkdown(refinedCandidate);
-    const contentHash = createHash("sha256").update(content).digest("hex");
+    const contentHash = createHash2("sha256").update(content).digest("hex");
     const semanticRefinementApplied = JSON.stringify(refinedCandidate.ruleUpdates) !== JSON.stringify(candidate.ruleUpdates);
     const changedRules = refinedCandidate.ruleUpdates.filter(
       (rule) => rule.delta !== 0
@@ -14064,13 +15236,13 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path3.join(
+    const metricsPath = path4.join(
       storage.dir,
       "state",
       "lifecycle-metrics.json"
     );
-    await mkdir3(path3.dirname(metricsPath), { recursive: true });
-    await writeFile3(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    await mkdir4(path4.dirname(metricsPath), { recursive: true });
+    await writeFile4(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
     return updatedCount;
   }
   /**
@@ -14098,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(
@@ -14120,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}`)
       );
     }
@@ -14603,7 +15770,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);
@@ -14633,7 +15800,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
@@ -14674,7 +15841,7 @@ ${lines.join("\n\n")}`;
         return null;
       }
     }
-    if (path3.isAbsolute(resultPath)) {
+    if (path4.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -14713,7 +15880,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,
@@ -14737,16 +15904,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)) {
@@ -14764,7 +15931,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(
@@ -14809,7 +15976,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,
@@ -14980,12 +16147,12 @@ ${lines.join("\n\n")}`;
    */
   semanticDedupScopeFor(targetStorage) {
     if (!this.config.namespacesEnabled) 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`
@@ -15004,7 +16171,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({
@@ -15179,7 +16346,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);
@@ -15203,8 +16370,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)
           )) {
@@ -15945,8 +17112,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path3.resolve(storageDir);
-    const resolvedMemoryDir = path3.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path4.resolve(storageDir);
+    const resolvedMemoryDir = path4.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir)
       return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
@@ -16076,4 +17243,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-OL2364SB.js.map
+//# sourceMappingURL=chunk-RDW5G6DO.js.map