@remnic/core 9.3.654 → 9.3.655

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

@@ -29,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-ZCORQM74.js";
+} from "./chunk-UYNFWZWG.js";
 import {
   SharedContextManager
 } from "./chunk-DRD2Q7HQ.js";
@@ -175,7 +175,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-NCGWXCSW.js";
+} from "./chunk-NRBGRZW4.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -210,7 +210,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-T2C6QJG2.js";
+} from "./chunk-BGKXTVNG.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-2PRQG7PV.js";
@@ -219,13 +219,13 @@ import {
 } from "./chunk-X6IRLNOO.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-QKK64Z6M.js";
+} from "./chunk-NCSJKK23.js";
 import {
   ThreadingManager
 } from "./chunk-W4RVMTHR.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-K6X553JB.js";
+} from "./chunk-UCEABZZN.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -239,7 +239,7 @@ import {
   NamespaceStorageRouter,
   resolveDefaultNamespaceRoot,
   resolveNamespaceStorageRoot
-} from "./chunk-3RACUBII.js";
+} from "./chunk-XRKQOQLY.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -317,14 +317,14 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-FVRBLJP6.js";
+} from "./chunk-54LOUIBE.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 +338,7 @@ import {
 } from "./chunk-OIF36KGD.js";
 import {
   parseQmdExplain
-} from "./chunk-PYWNNF2I.js";
+} from "./chunk-QRSKPI62.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -357,7 +357,7 @@ import {
 } from "./chunk-Y56J7CXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-Y2RIIF6H.js";
+} from "./chunk-PTMJ2FH2.js";
 import {
   ALL_CATEGORY_DIRS,
   ContentHashIndex,
@@ -368,7 +368,7 @@ import {
   normalizeEntityName,
   parseEntityFile,
   stripAttributesSuffix
-} from "./chunk-6CVI6BP6.js";
+} from "./chunk-TEO46GMM.js";
 import {
   isValidTranscriptDate,
   loadSpeakerRegistry,
@@ -383,11 +383,14 @@ import {
 } from "./chunk-J6A3CX5N.js";
 import {
   confidenceTier
-} from "./chunk-NE2JBMLN.js";
+} from "./chunk-TDZSSJV4.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus
 } from "./chunk-RULE4VG5.js";
+import {
+  displayErrorDetail
+} from "./chunk-6KYMPV2O.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -438,17 +441,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 +2054,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 +2117,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 +2282,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 +2466,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 +2868,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 +3534,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 +3584,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 +3597,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 +3607,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 +3729,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 +4034,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 +4180,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 +4188,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 +4208,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;
@@ -3737,6 +4349,7 @@ var Orchestrator = class _Orchestrator {
   qmdMaintenancePending = false;
   qmdMaintenanceInFlight = false;
   lastQmdEmbedAtMs = 0;
+  lastQmdEmbedAtMsByNamespace = /* @__PURE__ */ new Map();
   lastQmdReprobeAtMs = 0;
   tierMigrationInFlight = false;
   lastTierMigrationRunAtMs = 0;
@@ -4038,7 +4651,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 +4662,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 +4704,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 +4741,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 +4758,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;
@@ -4271,7 +4854,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path3.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path4.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -4316,7 +4899,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 +4956,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 +5035,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 +5255,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 +5537,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 +5652,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 +5705,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 +5727,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 +5747,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 +5767,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 +5829,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 +5886,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 +5902,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 +5919,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 +5929,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");
       }
     }
   }
@@ -5820,18 +6403,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 +6433,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 +6455,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 +6565,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 +6604,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 +6637,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 +6787,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;
@@ -6933,7 +7516,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 +7689,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 +7714,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 +7757,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 +7773,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 +7798,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 +7819,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 +7836,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 +7851,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 +7875,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 +7895,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 +7908,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 +8167,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 +8177,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";
@@ -7752,7 +8335,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))
@@ -9070,16 +9653,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 +9682,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 {
@@ -11204,7 +11787,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 +12044,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 = {}) {
@@ -11951,7 +12534,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 +12678,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();
@@ -13196,7 +13827,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 +14143,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 +14191,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 +14392,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 +14695,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;
   }
   /**
@@ -14603,7 +15234,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 +15264,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 +15305,7 @@ ${lines.join("\n\n")}`;
         return null;
       }
     }
-    if (path3.isAbsolute(resultPath)) {
+    if (path4.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -14713,7 +15344,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 +15368,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 +15395,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 +15440,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 +15611,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 +15635,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 +15810,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 +15834,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 +16576,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 +16707,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-OL2364SB.js.map
+//# sourceMappingURL=chunk-5QD3QD76.js.map