@remnic/core 10.0.3 → 10.0.4

package/dist/{chunk-6GU3TNJJ.js → chunk-QWNBQ2T5.js}

@@ -7,19 +7,22 @@ import {
   ensureProceduralMiningCron,
   graphEdgeDecayCadenceToCronExpr
 } from "./chunk-666A3MOW.js";
+import {
+  PROJECTION_REBUILD_RUNNER_FLAG
+} from "./chunk-FMIVV5SV.js";
 import {
   startLocationAutoSync
-} from "./chunk-PNFWIB4X.js";
+} from "./chunk-IHIP7TJ3.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-NXVD46HT.js";
+} from "./chunk-O57VUN4U.js";
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-HO7IQP7G.js";
+} from "./chunk-Y7CXM7UM.js";
 import {
   rebuildMemoryProjection
-} from "./chunk-X6X4UASX.js";
+} from "./chunk-DBA2W6VV.js";
 import {
   DEFAULT_TIMELINE_CATEGORIES,
   TIMELINE_RESERVED_IDLE,
@@ -31,6 +34,9 @@ import {
   validateActivityBaseUrl,
   validateTimelineCategories
 } from "./chunk-EUL3S3LE.js";
+import {
+  DEFAULT_PROJECTION_REBUILD_HEAP_USAGE_LIMIT
+} from "./chunk-EWMRFW3F.js";
 import {
   LocalLlmClient
 } from "./chunk-IDSSDL4W.js";
@@ -55,7 +61,7 @@ import {
   drainPendingLifecycleLedgerIfAny,
   pendingLifecycleLedgerDir,
   readProjectionRebuiltAt
-} from "./chunk-22DYJLFN.js";
+} from "./chunk-XVC7JU2N.js";
 import {
   displayErrorDetail,
   openBetterSqlite3
@@ -92,9 +98,9 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestration/maintenance.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { appendFile, lstat, mkdir as mkdir3, readFile as readFile2, readdir, realpath, stat, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 
 // src/maintenance/day-summary-cron.ts
 function resolveDaySummaryCronModel(config) {
@@ -123,11 +129,182 @@ function resolveDaySummaryCronModel(config) {
   return { ...model ? { model } : {}, fallbacks };
 }
 
+// src/orchestration/projection-rebuild-schedule.ts
+import { existsSync } from "fs";
+import { fork } from "child_process";
+import path from "path";
+import v8 from "v8";
+import { fileURLToPath } from "url";
+
+// src/orchestration/full-corpus-heap-guard.ts
+function fullCorpusHeapPressure(stats, limitRatio) {
+  const used = stats.used_heap_size;
+  const cap = stats.heap_size_limit;
+  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(cap) || cap <= 0 || !Number.isFinite(limitRatio)) {
+    return { postpone: false, ratio: 0 };
+  }
+  const ratio = used / cap;
+  return { postpone: ratio > limitRatio, ratio };
+}
+
 // src/orchestration/projection-rebuild-schedule.ts
 var FAILURE_RETRY_BACKOFF_MS = 5 * 60 * 1e3;
+var FORK_TIMEOUT_MS = 30 * 60 * 1e3;
+var MAX_SETTIMEOUT_MS = 2147483647;
+function projectionRebuildForkTimeoutMs(intervalMs) {
+  const timeout = !Number.isFinite(intervalMs) || intervalMs < FORK_TIMEOUT_MS ? FORK_TIMEOUT_MS : intervalMs;
+  return Math.min(timeout, MAX_SETTIMEOUT_MS);
+}
+var projectionRebuildChildren = /* @__PURE__ */ new Map();
+var parentExitHookInstalled = false;
+function rememberProjectionRebuildChild(child, owner) {
+  let children = projectionRebuildChildren.get(owner);
+  if (!children) {
+    children = /* @__PURE__ */ new Set();
+    projectionRebuildChildren.set(owner, children);
+  }
+  children.add(child);
+  const forget = () => {
+    children.delete(child);
+    if (children.size === 0) projectionRebuildChildren.delete(owner);
+  };
+  child.once("exit", forget);
+  child.once("error", forget);
+  if (!parentExitHookInstalled) {
+    parentExitHookInstalled = true;
+    process.on("exit", () => {
+      terminateScheduledProjectionRebuilds();
+    });
+  }
+}
+function terminateScheduledProjectionRebuilds(owner) {
+  const groups = owner ? [projectionRebuildChildren.get(owner)] : [...projectionRebuildChildren.values()];
+  for (const children of groups) {
+    if (!children) continue;
+    for (const child of children) child.kill("SIGKILL");
+  }
+}
+var CHILD_ENV_ALLOWLIST = [
+  "PATH",
+  "NODE_OPTIONS",
+  "HOME",
+  "USERPROFILE",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TZ",
+  "SystemRoot",
+  "windir",
+  "PATHEXT",
+  "COMSPEC",
+  "NODE_PATH"
+];
 function createProjectionRebuildScheduleState() {
   return { inFlight: false, lastRebuildAtMs: 0, lastFailureAtMs: 0 };
 }
+function projectionRebuildChildEnv(parent) {
+  const env = {};
+  for (const key of CHILD_ENV_ALLOWLIST) {
+    const value = parent[key];
+    if (value !== void 0) env[key] = value;
+  }
+  return env;
+}
+function projectionRebuildRunnerPath() {
+  const here = fileURLToPath(import.meta.url);
+  const dir = path.dirname(here);
+  const candidates = [
+    path.join(dir, "..", "maintenance", "rebuild-memory-projection-runner.ts"),
+    path.join(dir, "..", "maintenance", "rebuild-memory-projection-runner.js"),
+    path.join(dir, "maintenance", "rebuild-memory-projection-runner.js"),
+    path.join(dir, "rebuild-memory-projection-runner.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error("projection rebuild runner was not found next to the maintenance bundle");
+}
+function runnerExecArgv(runnerPath) {
+  const argv = [];
+  const source = process.execArgv;
+  for (let index = 0; index < source.length; index += 1) {
+    const arg = source[index] ?? "";
+    if (arg === "--inspect" || arg === "--inspect-brk" || arg === "--inspect-port") {
+      if (arg === "--inspect-port") index += 1;
+      continue;
+    }
+    if (arg.startsWith("--inspect=") || arg.startsWith("--inspect-brk=") || arg.startsWith("--inspect-port=")) {
+      continue;
+    }
+    argv.push(arg);
+  }
+  if (runnerPath.endsWith(".ts") && !argv.some((arg) => arg === "tsx" || arg.includes(`${path.sep}tsx`))) {
+    argv.unshift("--import", "tsx");
+  }
+  return argv;
+}
+function isRunnerSuccess(message) {
+  if (!message || typeof message !== "object") return false;
+  const row = message;
+  return row.ok === true && typeof row.currentRows === "number" && typeof row.timelineRows === "number" && typeof row.entityMentionRows === "number";
+}
+async function forkProjectionRebuild(request, options) {
+  const timeoutMs = Math.min(options?.timeoutMs ?? FORK_TIMEOUT_MS, MAX_SETTIMEOUT_MS);
+  const child = options?.spawnChild ? options.spawnChild() : spawnProjectionRebuildChild(request);
+  rememberProjectionRebuildChild(child, options?.owner);
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let timer;
+    const finish = (err, result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (err) reject(err);
+      else if (result) resolve(result);
+      else reject(new Error("projection rebuild runner returned no result"));
+    };
+    timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(new Error(`projection rebuild runner timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+    child.on("message", (message) => {
+      if (isRunnerSuccess(message)) {
+        finish(void 0, message);
+        return;
+      }
+      const error = message && typeof message === "object" && "error" in message ? String(message.error ?? "projection rebuild runner failed") : "projection rebuild runner failed";
+      finish(new Error(error));
+    });
+    child.on("error", (err) => finish(err));
+    child.on("exit", (code) => {
+      if (!settled) {
+        finish(new Error(`projection rebuild runner exited ${code ?? "null"}`));
+      }
+    });
+    options?.onChild?.(child);
+  });
+}
+function spawnProjectionRebuildChild(request) {
+  const runnerPath = projectionRebuildRunnerPath();
+  const nowIso = request.now.toISOString();
+  return fork(
+    runnerPath,
+    [PROJECTION_REBUILD_RUNNER_FLAG, request.memoryDir, request.defaultNamespace, nowIso],
+    {
+      execArgv: runnerExecArgv(runnerPath),
+      env: projectionRebuildChildEnv(process.env),
+      stdio: ["ignore", "inherit", "inherit", "ipc"]
+    }
+  );
+}
+function storageIsUnlocked(storage) {
+  if (!storage || typeof storage.isSecureStoreUnlocked !== "function") return false;
+  return storage.isSecureStoreUnlocked();
+}
 async function maybeRebuildMemoryProjectionScheduled(opts) {
   const { config, state } = opts;
   if (!resolveMemoryLifecycleCapabilities(config).projectionRebuild) return;
@@ -144,9 +321,21 @@ async function maybeRebuildMemoryProjectionScheduled(opts) {
     state.lastRebuildAtMs = rebuiltAtMs;
     return;
   }
+  const heapLimit = config.projectionRebuildHeapUsageLimit ?? DEFAULT_PROJECTION_REBUILD_HEAP_USAGE_LIMIT;
+  const heapStats = (opts.heapStatistics ?? (() => v8.getHeapStatistics()))();
+  const pressure = fullCorpusHeapPressure(heapStats, heapLimit);
+  if (pressure.postpone) {
+    state.lastFailureAtMs = Date.now();
+    log.warn(
+      `memory projection scheduled rebuild postponed for ${memoryDir}: heap used ${heapStats.used_heap_size} of limit ${heapStats.heap_size_limit} (ratio ${pressure.ratio.toFixed(3)}) exceeds projectionRebuildHeapUsageLimit ${heapLimit}`
+    );
+    return;
+  }
+  const forkRebuild = opts.forkRebuild ?? forkProjectionRebuild;
+  const unlocked = storageIsUnlocked(rootStorage);
   state.inFlight = true;
   try {
-    const result = await rebuildMemoryProjection({
+    const result = unlocked ? await rebuildMemoryProjection({
       memoryDir,
       // Reuse the daemon's live storage so secure-store deployments rebuild
       // through the unlocked instance instead of a fresh locked one.
@@ -154,6 +343,13 @@ async function maybeRebuildMemoryProjectionScheduled(opts) {
       defaultNamespace: config.defaultNamespace,
       dryRun: false,
       now: new Date(now)
+    }) : await forkRebuild({
+      memoryDir,
+      defaultNamespace: config.defaultNamespace || "default",
+      now: new Date(now)
+    }, {
+      timeoutMs: projectionRebuildForkTimeoutMs(intervalMs),
+      owner: state
     });
     state.lastRebuildAtMs = Date.now();
     const lag = Number.isFinite(rebuiltAtMs) ? `${Math.max(0, Math.round((now - rebuiltAtMs) / 6e4))}m stale` : "never previously built";
@@ -185,17 +381,17 @@ async function refreshActivityIndex(qmd, collection, signal) {
 // src/activity/store.ts
 import { mkdirSync } from "fs";
 import { mkdir } from "fs/promises";
-import path from "path";
+import path2 from "path";
 var ACTIVITY_SCHEMA_VERSION = 1;
 var MAX_SEARCH_RESULTS = 100;
 function activityDatabasePath(memoryDir) {
-  return path.join(memoryDir, "state", "activity.sqlite");
+  return path2.join(memoryDir, "state", "activity.sqlite");
 }
 async function ensureActivityStateDir(memoryDir) {
-  await mkdir(path.join(memoryDir, "state"), { recursive: true });
+  await mkdir(path2.join(memoryDir, "state"), { recursive: true });
 }
 function openActivityDatabase(memoryDir) {
-  mkdirSync(path.join(memoryDir, "state"), { recursive: true });
+  mkdirSync(path2.join(memoryDir, "state"), { recursive: true });
   const db = openBetterSqlite3(activityDatabasePath(memoryDir));
   db.pragma("journal_mode = WAL");
   db.pragma("busy_timeout = 5000");
@@ -444,7 +640,7 @@ var ActivityStore = class _ActivityStore {
 // src/activity/pipeline.ts
 import { mkdir as mkdir2, readFile, rename, writeFile } from "fs/promises";
 import { randomUUID } from "crypto";
-import path2 from "path";
+import path3 from "path";
 var MAX_SYNC_PAGES = 1e4;
 function activityCursorKey(machine, date) {
   return `${machine}\0${date}`;
@@ -483,7 +679,7 @@ async function writeDigestIfChanged(memoryDir, date, serialized) {
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
   }
-  await mkdir2(path2.dirname(target), { recursive: true, mode: 448 });
+  await mkdir2(path3.dirname(target), { recursive: true, mode: 448 });
   const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
   await writeFile(temporary, serialized, { encoding: "utf8", mode: 384 });
   await rename(temporary, target);
@@ -630,8 +826,8 @@ function responsePage(value, machine) {
     nextCursor
   };
 }
-function requestUrl(baseUrl, path6, query) {
-  const url = new URL(path6, baseUrl);
+function requestUrl(baseUrl, path7, query) {
+  const url = new URL(path7, baseUrl);
   const parts = Object.entries(query).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
   url.search = parts.join("&");
   return url.toString();
@@ -686,13 +882,13 @@ var ActivityHttpSourceClient = class {
 // src/activity/timeline/regenerate.ts
 import { randomBytes } from "crypto";
 import { mkdirSync as mkdirSync3, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
-import path4 from "path";
+import path5 from "path";
 
 // src/activity/timeline/corrections.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import path3 from "path";
+import path4 from "path";
 function timelineCorrectionDatabasePath(memoryDir) {
-  return path3.join(memoryDir, "state", "activity-timeline.sqlite");
+  return path4.join(memoryDir, "state", "activity-timeline.sqlite");
 }
 function rowToCorrection(row) {
   return {
@@ -708,7 +904,7 @@ var TimelineCorrectionStore = class _TimelineCorrectionStore {
     this.db = db;
   }
   static open(memoryDir) {
-    mkdirSync2(path3.join(memoryDir, "state"), { recursive: true });
+    mkdirSync2(path4.join(memoryDir, "state"), { recursive: true });
     const db = openBetterSqlite3(timelineCorrectionDatabasePath(memoryDir));
     db.pragma("journal_mode = WAL");
     db.pragma("busy_timeout = 5000");
@@ -1092,7 +1288,7 @@ async function runTimelineCardAnalysis(input) {
 
 // src/activity/timeline/regenerate.ts
 var TIMELINE_DAY_FORMAT_VERSION = 1;
-var TIMELINE_DAY_DIR = path4.join("activity", "timeline");
+var TIMELINE_DAY_DIR = path5.join("activity", "timeline");
 var inflight = /* @__PURE__ */ new Map();
 function requireToken(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
@@ -1105,7 +1301,7 @@ function timelineDayPath(memoryDir, date) {
   if (!isValidActivityDate(date)) {
     throw new RangeError("date must be a real YYYY-MM-DD day");
   }
-  return path4.join(path4.resolve(root), TIMELINE_DAY_DIR, `${date}.json`);
+  return path5.join(path5.resolve(root), TIMELINE_DAY_DIR, `${date}.json`);
 }
 function snapshotToObservation(snapshot) {
   if (typeof snapshot.id !== "number") return null;
@@ -1135,7 +1331,7 @@ function localDatesForUtcRange(fromMs, toMs, timezone) {
 function listPersistedTimelineDates(memoryDir) {
   let entries;
   try {
-    entries = readdirSync(path4.join(path4.resolve(requireToken(memoryDir, "memoryDir")), TIMELINE_DAY_DIR));
+    entries = readdirSync(path5.join(path5.resolve(requireToken(memoryDir, "memoryDir")), TIMELINE_DAY_DIR));
   } catch {
     return [];
   }
@@ -1229,7 +1425,7 @@ function persistDay(filePath, payload) {
       throw error;
     }
   }
-  mkdirSync3(path4.dirname(filePath), { recursive: true, mode: 448 });
+  mkdirSync3(path5.dirname(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
   writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
   try {
@@ -1324,7 +1520,7 @@ async function regenerateUncached(input) {
   }
 }
 async function regenerateTimelineDay(input) {
-  const key = `${path4.resolve(requireToken(input.memoryDir, "memoryDir"))}\0${input.date}`;
+  const key = `${path5.resolve(requireToken(input.memoryDir, "memoryDir"))}\0${input.date}`;
   const pending = inflight.get(key);
   if (pending !== void 0) return pending;
   const run = regenerateUncached(input).finally(() => {
@@ -1716,9 +1912,9 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
-      if (!existsSync(jobsPath)) {
+      if (!existsSync2(jobsPath)) {
         log.debug("day-summary cron: jobs.json not found, skipping auto-register");
         return;
       }
@@ -1746,9 +1942,9 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
-      if (!existsSync(jobsPath)) {
+      if (!existsSync2(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
         return;
       }
@@ -1768,9 +1964,9 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
-      if (!existsSync(jobsPath)) {
+      if (!existsSync2(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
         return;
       }
@@ -1788,9 +1984,9 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
-      if (!existsSync(jobsPath)) {
+      if (!existsSync2(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
         return;
       }
@@ -1808,9 +2004,9 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
-      if (!existsSync(jobsPath)) {
+      if (!existsSync2(jobsPath)) {
         log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
         return;
       }
@@ -1828,9 +2024,9 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
-      if (!existsSync(jobsPath)) {
+      if (!existsSync2(jobsPath)) {
         log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
         return;
       }
@@ -2100,7 +2296,7 @@ var MaintenanceScheduler = class {
    */
   async hasOverCapEncryptedLifecycleLedger(targets) {
     for (const target of targets) {
-      const ledgerPath = path5.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+      const ledgerPath = path6.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
       let size;
       try {
         size = (await stat(ledgerPath)).size;
@@ -2152,7 +2348,7 @@ var MaintenanceScheduler = class {
    * containment guard on every spill file it reads or deletes.
    */
   async drainPendingLifecycleAppendsForPath(memoryDir) {
-    const ledgerPath = path5.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path6.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     const spillDir = pendingLifecycleLedgerDir(ledgerPath);
     let spillFiles;
     let claimedOrphans;
@@ -2166,7 +2362,7 @@ var MaintenanceScheduler = class {
     if (spillFiles.length === 0 && claimedOrphans.length === 0) return;
     const io = {
       writeSecure: async (filePath, payload) => {
-        await mkdir3(path5.dirname(filePath), { recursive: true });
+        await mkdir3(path6.dirname(filePath), { recursive: true });
         await writeFile2(filePath, payload, "utf-8");
       },
       readSecure: async (filePath) => {
@@ -2187,7 +2383,7 @@ var MaintenanceScheduler = class {
           await appendFile(ledgerPath, payload, "utf-8");
         },
         async () => {
-          await mkdir3(path5.dirname(ledgerPath), { recursive: true });
+          await mkdir3(path6.dirname(ledgerPath), { recursive: true });
         }
       );
     } catch (err) {
@@ -2205,7 +2401,7 @@ var MaintenanceScheduler = class {
     const targets = [];
     const seen = /* @__PURE__ */ new Set();
     const addTarget = (memoryDir, storage) => {
-      const key = path5.resolve(memoryDir);
+      const key = path6.resolve(memoryDir);
       if (seen.has(key)) return;
       seen.add(key);
       targets.push({ memoryDir, storage });
@@ -2234,7 +2430,7 @@ var MaintenanceScheduler = class {
       }
     }
     if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      const namespacesBase = path5.join(this.deps.config.memoryDir, "namespaces");
+      const namespacesBase = path6.join(this.deps.config.memoryDir, "namespaces");
       let memoryDirReal;
       try {
         memoryDirReal = await realpath(this.deps.config.memoryDir);
@@ -2259,7 +2455,7 @@ var MaintenanceScheduler = class {
       }
       for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-        const childPath = path5.join(namespacesBase, entry.name);
+        const childPath = path6.join(namespacesBase, entry.name);
         try {
           assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);
         } catch (err) {
@@ -2271,7 +2467,7 @@ var MaintenanceScheduler = class {
         if (resolveNamespaceStorage && routeNamespace !== null) {
           try {
             const storage = await resolveNamespaceStorage(routeNamespace);
-            if (path5.resolve(storage.dir) === path5.resolve(childPath)) {
+            if (path6.resolve(storage.dir) === path6.resolve(childPath)) {
               addTarget(storage.dir, storage);
               continue;
             }
@@ -2302,7 +2498,7 @@ var MaintenanceScheduler = class {
    * an over-cap rewrite never arms the throttle.
    */
   async compactLifecycleLedgerTarget(target, threshold) {
-    const ledgerPath = path5.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path6.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     let size = 0;
     try {
       size = (await stat(ledgerPath)).size;
@@ -2394,6 +2590,7 @@ var MaintenanceScheduler = class {
    */
   async dispose() {
     this.disposed = true;
+    terminateScheduledProjectionRebuilds(this.projectionRebuild);
     const consolidationDrain = this.consolidationRunPromise;
     const activityDrain = this.activityRegistrar.dispose();
     const locationDrain = this.locationAutoSync?.stop() ?? Promise.resolve();
@@ -2450,4 +2647,4 @@ export {
   ActivitySyncScheduler,
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-6GU3TNJJ.js.map
+//# sourceMappingURL=chunk-QWNBQ2T5.js.map