@remnic/core 10.0.51 → 10.0.53

package/dist/{chunk-EC2KVA27.js → chunk-H4DWSOBQ.js}

@@ -9,26 +9,26 @@ import {
 } from "./chunk-666A3MOW.js";
 import {
   PROJECTION_REBUILD_RUNNER_FLAG
-} from "./chunk-LWMLBVGB.js";
+} from "./chunk-B43P3DTC.js";
 import {
   startLocationAutoSync
-} from "./chunk-KAJYSO3U.js";
+} from "./chunk-6CDNOREO.js";
 import {
   CompoundingEngine,
   isIsoWeekId,
   msUntilNextIsoWeek,
   previousIsoWeekId
-} from "./chunk-B35EQQ7L.js";
+} from "./chunk-53OFDW3P.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-EZS6QJNC.js";
+} from "./chunk-IFOCK3OJ.js";
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-72CBJ5VP.js";
+} from "./chunk-R3WZ74B2.js";
 import {
   rebuildMemoryProjection
-} from "./chunk-DQOGZZJA.js";
+} from "./chunk-QAHP5SBG.js";
 import {
   DEFAULT_TIMELINE_CATEGORIES,
   TIMELINE_RESERVED_IDLE,
@@ -108,8 +108,8 @@ import {
 
 // src/orchestration/maintenance.ts
 import { existsSync as existsSync2 } from "fs";
-import { appendFile, lstat as lstat2, mkdir as mkdir3, readFile as readFile2, readdir, realpath, stat, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
+import { lstat as lstat2, readdir, realpath, stat } from "fs/promises";
+import path8 from "path";
 
 // src/maintenance/day-summary-cron.ts
 function resolveDaySummaryCronModel(config) {
@@ -373,14 +373,85 @@ async function maybeRebuildMemoryProjectionScheduled(opts) {
   }
 }
 
+// src/orchestration/lifecycle-pending-fallback-drain.ts
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import path2 from "path";
+async function drainPendingLifecycleAppendsForPath(memoryDir) {
+  const ledgerPath = path2.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+  const spillDir = pendingLifecycleLedgerDir(ledgerPath);
+  let spillFiles;
+  let claimedOrphans;
+  try {
+    spillFiles = await listContainedSpillFiles(spillDir);
+    claimedOrphans = await listContainedSpillFiles(spillDir, ".jsonl.claimed");
+  } catch (err) {
+    log.debug(`fallback lifecycle pending scan failed (non-fatal) for ${memoryDir}: ${err}`);
+    return;
+  }
+  if (spillFiles.length === 0 && claimedOrphans.length === 0) return;
+  const io = {
+    writeSecure: async (filePath, payload) => {
+      await mkdir(path2.dirname(filePath), { recursive: true });
+      await writeFile(filePath, payload, "utf-8");
+    },
+    readSecure: async (filePath) => {
+      if (await probeEncryptedRegularFileHeader(filePath)) {
+        throw new Error(`fallback lifecycle drain deferred: encrypted spill at ${filePath}`);
+      }
+      return readFile(filePath, "utf-8");
+    }
+  };
+  try {
+    await drainPendingLifecycleLedgerIfAny(
+      ledgerPath,
+      io,
+      async (payload) => {
+        if (await probeEncryptedRegularFileHeader(ledgerPath)) {
+          throw new Error(`fallback lifecycle drain deferred: ledger became encrypted at ${ledgerPath}`);
+        }
+        await appendFile(ledgerPath, payload, "utf-8");
+      },
+      async () => {
+        await mkdir(path2.dirname(ledgerPath), { recursive: true });
+      }
+    );
+  } catch (err) {
+    log.debug(`fallback lifecycle pending drain failed (non-fatal) for ${memoryDir}: ${err}`);
+  }
+}
+
+// src/orchestration/qmd-maintenance-completion.ts
+var QmdMaintenanceCompletion = class {
+  waiters = [];
+  /** Resolves true when a pass that started after this call completed successfully. */
+  wait() {
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+  /**
+   * A pass is starting: take every waiter it will serve and return their settle function.
+   * `defer` keeps them waiting for a later pass (a pass that covered only part of the selection).
+   */
+  claim() {
+    const claimed = this.waiters.splice(0);
+    return (served, defer = false) => {
+      if (defer) this.waiters.unshift(...claimed);
+      else claimed.forEach((resolve) => resolve(served));
+    };
+  }
+  /** The scheduler stopped: nothing will serve the waiters. */
+  abandon() {
+    this.claim()(false);
+  }
+};
+
 // src/compounding/weekly-scheduler.ts
 import { lstat } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 function compoundingWeeklyDoneMarkerPath(memoryDir, weekId) {
   if (!isIsoWeekId(weekId)) {
     throw new Error("compounding weekly cron: week id must be YYYY-Www");
   }
-  return path2.join(memoryDir, "compounding", "weekly", ".scheduler", `${weekId}.done`);
+  return path3.join(memoryDir, "compounding", "weekly", ".scheduler", `${weekId}.done`);
 }
 async function defaultWeekDone(memoryDir, weekId) {
   try {
@@ -517,18 +588,18 @@ async function refreshActivityIndex(qmd, collection, signal) {
 
 // src/activity/store.ts
 import { mkdirSync } from "fs";
-import { mkdir } from "fs/promises";
-import path3 from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+import path4 from "path";
 var ACTIVITY_SCHEMA_VERSION = 1;
 var MAX_SEARCH_RESULTS = 100;
 function activityDatabasePath(memoryDir) {
-  return path3.join(memoryDir, "state", "activity.sqlite");
+  return path4.join(memoryDir, "state", "activity.sqlite");
 }
 async function ensureActivityStateDir(memoryDir) {
-  await mkdir(path3.join(memoryDir, "state"), { recursive: true });
+  await mkdir2(path4.join(memoryDir, "state"), { recursive: true });
 }
 function openActivityDatabase(memoryDir) {
-  mkdirSync(path3.join(memoryDir, "state"), { recursive: true });
+  mkdirSync(path4.join(memoryDir, "state"), { recursive: true });
   const db = openBetterSqlite3(activityDatabasePath(memoryDir));
   db.pragma("journal_mode = WAL");
   db.pragma("busy_timeout = 5000");
@@ -775,9 +846,9 @@ var ActivityStore = class _ActivityStore {
 };
 
 // src/activity/pipeline.ts
-import { mkdir as mkdir2, readFile, rename, writeFile } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
 import { randomUUID } from "crypto";
-import path4 from "path";
+import path5 from "path";
 var MAX_SYNC_PAGES = 1e4;
 function activityCursorKey(machine, date) {
   return `${machine}\0${date}`;
@@ -812,13 +883,13 @@ function snapshotForMachine(snapshot, machine) {
 async function writeDigestIfChanged(memoryDir, date, serialized) {
   const target = activityDigestPath(memoryDir, date);
   try {
-    if (await readFile(target, "utf8") === serialized) return false;
+    if (await readFile2(target, "utf8") === serialized) return false;
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
   }
-  await mkdir2(path4.dirname(target), { recursive: true, mode: 448 });
+  await mkdir3(path5.dirname(target), { recursive: true, mode: 448 });
   const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
-  await writeFile(temporary, serialized, { encoding: "utf8", mode: 384 });
+  await writeFile2(temporary, serialized, { encoding: "utf8", mode: 384 });
   await rename(temporary, target);
   return true;
 }
@@ -963,8 +1034,8 @@ function responsePage(value, machine) {
     nextCursor
   };
 }
-function requestUrl(baseUrl, path8, query) {
-  const url = new URL(path8, baseUrl);
+function requestUrl(baseUrl, path9, query) {
+  const url = new URL(path9, 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();
@@ -1019,13 +1090,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 path6 from "path";
+import path7 from "path";
 
 // src/activity/timeline/corrections.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import path5 from "path";
+import path6 from "path";
 function timelineCorrectionDatabasePath(memoryDir) {
-  return path5.join(memoryDir, "state", "activity-timeline.sqlite");
+  return path6.join(memoryDir, "state", "activity-timeline.sqlite");
 }
 function rowToCorrection(row) {
   return {
@@ -1041,7 +1112,7 @@ var TimelineCorrectionStore = class _TimelineCorrectionStore {
     this.db = db;
   }
   static open(memoryDir) {
-    mkdirSync2(path5.join(memoryDir, "state"), { recursive: true });
+    mkdirSync2(path6.join(memoryDir, "state"), { recursive: true });
     const db = openBetterSqlite3(timelineCorrectionDatabasePath(memoryDir));
     db.pragma("journal_mode = WAL");
     db.pragma("busy_timeout = 5000");
@@ -1425,7 +1496,7 @@ async function runTimelineCardAnalysis(input) {
 
 // src/activity/timeline/regenerate.ts
 var TIMELINE_DAY_FORMAT_VERSION = 1;
-var TIMELINE_DAY_DIR = path6.join("activity", "timeline");
+var TIMELINE_DAY_DIR = path7.join("activity", "timeline");
 var inflight = /* @__PURE__ */ new Map();
 function requireToken(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
@@ -1438,7 +1509,7 @@ function timelineDayPath(memoryDir, date) {
   if (!isValidActivityDate(date)) {
     throw new RangeError("date must be a real YYYY-MM-DD day");
   }
-  return path6.join(path6.resolve(root), TIMELINE_DAY_DIR, `${date}.json`);
+  return path7.join(path7.resolve(root), TIMELINE_DAY_DIR, `${date}.json`);
 }
 function snapshotToObservation(snapshot) {
   if (typeof snapshot.id !== "number") return null;
@@ -1468,7 +1539,7 @@ function localDatesForUtcRange(fromMs, toMs, timezone) {
 function listPersistedTimelineDates(memoryDir) {
   let entries;
   try {
-    entries = readdirSync(path6.join(path6.resolve(requireToken(memoryDir, "memoryDir")), TIMELINE_DAY_DIR));
+    entries = readdirSync(path7.join(path7.resolve(requireToken(memoryDir, "memoryDir")), TIMELINE_DAY_DIR));
   } catch {
     return [];
   }
@@ -1562,7 +1633,7 @@ function persistDay(filePath, payload) {
       throw error;
     }
   }
-  mkdirSync3(path6.dirname(filePath), { recursive: true, mode: 448 });
+  mkdirSync3(path7.dirname(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
   writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
   try {
@@ -1657,7 +1728,7 @@ async function regenerateUncached(input) {
   }
 }
 async function regenerateTimelineDay(input) {
-  const key = `${path6.resolve(requireToken(input.memoryDir, "memoryDir"))}\0${input.date}`;
+  const key = `${path7.resolve(requireToken(input.memoryDir, "memoryDir"))}\0${input.date}`;
   const pending = inflight.get(key);
   if (pending !== void 0) return pending;
   const run = regenerateUncached(input).finally(() => {
@@ -1965,6 +2036,9 @@ var MaintenanceScheduler = class {
   qmdMaintenanceTimer = null;
   qmdMaintenancePending = false;
   qmdMaintenanceInFlight = false;
+  qmdCompletion = new QmdMaintenanceCompletion();
+  /** Namespaces that ran in passes of the request still waiting for full coverage. */
+  qmdCoveredNamespaces = /* @__PURE__ */ new Set();
   lastQmdEmbedAtMs = 0;
   lastQmdEmbedAtMsByNamespace = /* @__PURE__ */ new Map();
   // ── Lifecycle-ledger auto-compaction state (issue #1910) ──
@@ -2055,7 +2129,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path8.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("day-summary cron: jobs.json not found, skipping auto-register");
@@ -2085,7 +2159,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path8.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -2107,7 +2181,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path8.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -2127,7 +2201,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path8.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -2147,7 +2221,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path8.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
@@ -2167,7 +2241,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path8.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
@@ -2241,18 +2315,29 @@ var MaintenanceScheduler = class {
   // ───────────────────────────────────────────────────────────────────────
   // QMD maintenance scheduling (debounced + singleflight)
   // ───────────────────────────────────────────────────────────────────────
-  /** Internal: queue a debounced QMD maintenance pass. */
+  /** Internal: queue a debounced QMD maintenance pass; false when nothing could be armed. */
   requestQmdMaintenance() {
-    if (!this.deps.getQmd().isAvailable()) return;
-    if (!resolveQmdCapabilities(this.deps.config).qmdMaintenance) return;
+    if (!this.deps.getQmd().isAvailable()) return false;
+    if (!resolveQmdCapabilities(this.deps.config).qmdMaintenance) return false;
     this.qmdMaintenancePending = true;
-    if (this.qmdMaintenanceTimer) return;
+    if (this.qmdMaintenanceTimer) return true;
     this.qmdMaintenanceTimer = setTimeout(() => {
       this.qmdMaintenanceTimer = null;
       this.runQmdMaintenance().catch(
         (err) => log.debug(`background qmd maintenance failed: ${err}`)
       );
     }, this.deps.config.qmdMaintenanceDebounceMs);
+    return true;
+  }
+  /**
+   * Like a maintenance request, but resolves true only once a pass that started
+   * after it completed successfully. False when nothing could be armed (QMD
+   * unavailable or maintenance off), the pass failed, or dispose() abandoned it,
+   * so a caller that must not lose the re-index keeps owing it.
+   */
+  requestQmdMaintenanceCompletion() {
+    if (this.disposed || !this.requestQmdMaintenance()) return Promise.resolve(false);
+    return this.qmdCompletion.wait();
   }
   /**
    * Public entrypoint for tool-driven QMD maintenance requests.
@@ -2282,6 +2367,9 @@ var MaintenanceScheduler = class {
     if (!this.qmdMaintenancePending) return;
     this.qmdMaintenanceInFlight = true;
     this.qmdMaintenancePending = false;
+    const settle = this.qmdCompletion.claim();
+    let served = false;
+    let deferred = false;
     try {
       if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
         const plan = await this.namespaceMaintenancePlan("qmd");
@@ -2300,7 +2388,7 @@ var MaintenanceScheduler = class {
           }
           this.lastQmdEmbedAtMs = now;
         };
-        await runNamespaceMaintenanceBatchPlan(
+        const summary = await runNamespaceMaintenanceBatchPlan(
           this.deps.config,
           plan,
           async (candidates) => {
@@ -2347,8 +2435,34 @@ var MaintenanceScheduler = class {
             skipReasonForError: qmdMaintenanceSkipReasonForError
           }
         );
+        const covered = this.qmdCoveredNamespaces;
+        const before = covered.size;
+        for (const status of summary.statuses) {
+          if (status.state === "ran") covered.add(status.namespace);
+        }
+        const uncovered = summary.statuses.some(
+          (status) => status.state === "skipped" && (status.reason === "budget_exhausted" || status.reason === "lock_held") && !covered.has(status.namespace)
+        );
+        served = summary.ran > 0 && summary.failed === 0 && !uncovered;
+        deferred = !served && summary.failed === 0 && covered.size > before && !this.disposed;
       } else {
-        await this.deps.getQmd().update();
+        const qmd = this.deps.getQmd();
+        if (qmd.updateCompleted) {
+          try {
+            served = await qmd.updateCompleted();
+          } catch (err) {
+            log.debug(`qmd maintenance update did not run: ${err}`);
+          }
+        } else if (qmd.updateStrict) {
+          try {
+            await qmd.updateStrict();
+            served = true;
+          } catch (err) {
+            log.debug(`qmd maintenance update did not run: ${err}`);
+          }
+        } else {
+          await qmd.update();
+        }
         const now = Date.now();
         if (resolveQmdCapabilities(this.deps.config).qmdAutoEmbed && now - this.lastQmdEmbedAtMs >= this.deps.config.qmdEmbedMinIntervalMs) {
           await this.deps.getQmd().embed();
@@ -2356,7 +2470,10 @@ var MaintenanceScheduler = class {
         }
       }
     } finally {
+      settle(served, deferred);
+      if (!deferred) this.qmdCoveredNamespaces.clear();
       this.qmdMaintenanceInFlight = false;
+      if (deferred) this.qmdMaintenancePending = true;
       if (this.qmdMaintenancePending) {
         this.requestQmdMaintenance();
       }
@@ -2439,7 +2556,7 @@ var MaintenanceScheduler = class {
    */
   async hasOverCapEncryptedLifecycleLedger(targets) {
     for (const target of targets) {
-      const ledgerPath = path7.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+      const ledgerPath = path8.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
       let size;
       try {
         size = (await stat(ledgerPath)).size;
@@ -2466,7 +2583,7 @@ var MaintenanceScheduler = class {
     if (target.storage) {
       await this.drainPendingLifecycleAppends(target.storage);
     } else {
-      await this.drainPendingLifecycleAppendsForPath(target.memoryDir);
+      await drainPendingLifecycleAppendsForPath(target.memoryDir);
     }
   }
   /** Drain a target's durable pending lifecycle-append spill into its ledger
@@ -2479,60 +2596,6 @@ var MaintenanceScheduler = class {
       log.debug(`lifecycle pending drain failed (non-fatal): ${err}`);
     }
   }
-  /**
-   * Drain a filesystem-fallback target's pending lifecycle-append spill when no
-   * secure StorageManager is available (catalog-disabled namespace; issue
-   * #2033). Uses the safe path-scoped PLAINTEXT context this fallback already
-   * operates in: a keyless drain can only fold plaintext spills into a plaintext
-   * ledger, so it refuses when the ledger or ANY spill is encrypted at rest,
-   * leaving those pending for a keyed (catalog-path) drain — exactly mirroring
-   * the fallback compaction's encrypted-ledger deferral. Non-fatal; a fast
-   * no-op when nothing is pending. The shared spill lister enforces the symlink/
-   * containment guard on every spill file it reads or deletes.
-   */
-  async drainPendingLifecycleAppendsForPath(memoryDir) {
-    const ledgerPath = path7.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
-    const spillDir = pendingLifecycleLedgerDir(ledgerPath);
-    let spillFiles;
-    let claimedOrphans;
-    try {
-      spillFiles = await listContainedSpillFiles(spillDir);
-      claimedOrphans = await listContainedSpillFiles(spillDir, ".jsonl.claimed");
-    } catch (err) {
-      log.debug(`fallback lifecycle pending scan failed (non-fatal) for ${memoryDir}: ${err}`);
-      return;
-    }
-    if (spillFiles.length === 0 && claimedOrphans.length === 0) return;
-    const io = {
-      writeSecure: async (filePath, payload) => {
-        await mkdir3(path7.dirname(filePath), { recursive: true });
-        await writeFile2(filePath, payload, "utf-8");
-      },
-      readSecure: async (filePath) => {
-        if (await probeEncryptedRegularFileHeader(filePath)) {
-          throw new Error(`fallback lifecycle drain deferred: encrypted spill at ${filePath}`);
-        }
-        return readFile2(filePath, "utf-8");
-      }
-    };
-    try {
-      await drainPendingLifecycleLedgerIfAny(
-        ledgerPath,
-        io,
-        async (payload) => {
-          if (await probeEncryptedRegularFileHeader(ledgerPath)) {
-            throw new Error(`fallback lifecycle drain deferred: ledger became encrypted at ${ledgerPath}`);
-          }
-          await appendFile(ledgerPath, payload, "utf-8");
-        },
-        async () => {
-          await mkdir3(path7.dirname(ledgerPath), { recursive: true });
-        }
-      );
-    } catch (err) {
-      log.debug(`fallback lifecycle pending drain failed (non-fatal) for ${memoryDir}: ${err}`);
-    }
-  }
   /**
    * Enumerate the lifecycle ledgers to consider for compaction: the root
    * (through the secure-configured root storage when available) plus every
@@ -2544,7 +2607,7 @@ var MaintenanceScheduler = class {
     const targets = [];
     const seen = /* @__PURE__ */ new Set();
     const addTarget = (memoryDir, storage) => {
-      const key = path7.resolve(memoryDir);
+      const key = path8.resolve(memoryDir);
       if (seen.has(key)) return;
       seen.add(key);
       targets.push({ memoryDir, storage });
@@ -2573,7 +2636,7 @@ var MaintenanceScheduler = class {
       }
     }
     if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      const namespacesBase = path7.join(this.deps.config.memoryDir, "namespaces");
+      const namespacesBase = path8.join(this.deps.config.memoryDir, "namespaces");
       let memoryDirReal;
       try {
         memoryDirReal = await realpath(this.deps.config.memoryDir);
@@ -2598,7 +2661,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 = path7.join(namespacesBase, entry.name);
+        const childPath = path8.join(namespacesBase, entry.name);
         try {
           assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);
         } catch (err) {
@@ -2610,7 +2673,7 @@ var MaintenanceScheduler = class {
         if (resolveNamespaceStorage && routeNamespace !== null) {
           try {
             const storage = await resolveNamespaceStorage(routeNamespace);
-            if (path7.resolve(storage.dir) === path7.resolve(childPath)) {
+            if (path8.resolve(storage.dir) === path8.resolve(childPath)) {
               addTarget(storage.dir, storage);
               continue;
             }
@@ -2641,7 +2704,7 @@ var MaintenanceScheduler = class {
    * an over-cap rewrite never arms the throttle.
    */
   async compactLifecycleLedgerTarget(target, threshold) {
-    const ledgerPath = path7.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path8.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     let size = 0;
     try {
       size = (await stat(ledgerPath)).size;
@@ -2745,6 +2808,7 @@ var MaintenanceScheduler = class {
       this.qmdMaintenanceTimer = null;
     }
     this.qmdMaintenancePending = false;
+    this.qmdCompletion.abandon();
     await activityDrain;
     await locationDrain;
     await weeklyDrain;
@@ -2793,4 +2857,4 @@ export {
   ActivitySyncScheduler,
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-EC2KVA27.js.map
+//# sourceMappingURL=chunk-H4DWSOBQ.js.map