@remnic/core 9.7.14 → 9.8.0

package/dist/{chunk-NUWYOKS6.js → chunk-MC5Q3J7S.js}

@@ -7,25 +7,51 @@ import {
   ensureProceduralMiningCron,
   graphEdgeDecayCadenceToCronExpr
 } from "./chunk-666A3MOW.js";
+import {
+  rebuildMemoryLifecycleLedger
+} from "./chunk-7RNBVZZO.js";
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-5UNWK7KU.js";
+} from "./chunk-GFPZS3F5.js";
+import {
+  STATE_FILE_MAX_DECRYPT_BYTES,
+  drainPendingLifecycleLedgerIfAny,
+  pendingLifecycleLedgerDir
+} from "./chunk-AVPXXV6J.js";
+import {
+  namespaceIdentityFromToken
+} from "./chunk-EGGE52UU.js";
+import {
+  assertPathInsideRoot,
+  listContainedSpillFiles
+} from "./chunk-GCASGYIO.js";
+import {
+  resolveHomeDir
+} from "./chunk-JUC24CTX.js";
+import {
+  SECURE_STORE_ENVELOPE_OVERHEAD_BYTES,
+  probeEncryptedRegularFileHeader
+} from "./chunk-AIK5W3IW.js";
+import {
+  isErrnoCode
+} from "./chunk-5UZXUTVO.js";
+import {
+  isSafeRouteNamespace
+} from "./chunk-U3PN77QT.js";
 import {
   resolveConsolidationCapabilities,
   resolveNamespaceCapabilities,
   resolveQmdCapabilities,
   resolveRecallAuxiliaryCapabilities
-} from "./chunk-BFPETA3S.js";
-import {
-  resolveHomeDir
-} from "./chunk-JUC24CTX.js";
+} from "./chunk-SCCO46KZ.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/orchestration/maintenance.ts
 import { existsSync } from "fs";
+import { appendFile, lstat, mkdir, readFile, readdir, realpath, stat, writeFile } from "fs/promises";
 import path from "path";
 function qmdMaintenanceSkipReasonForError(error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -46,6 +72,15 @@ var MaintenanceScheduler = class {
   qmdMaintenanceInFlight = false;
   lastQmdEmbedAtMs = 0;
   lastQmdEmbedAtMsByNamespace = /* @__PURE__ */ new Map();
+  // ── Lifecycle-ledger auto-compaction state (issue #1910) ──
+  lifecycleCompactionInFlight = false;
+  lastLifecycleCompactionAtMs = 0;
+  // Upper bound on a rewritten ledger; a preserving compaction is bounded to
+  // this so it can never leave the ledger over the whole-file read/decrypt cap
+  // (#2033). Defaults to the decrypt cap; overridable in focused tests to drive
+  // the bounding + post-write verification deterministically without a 400MB
+  // fixture.
+  lifecycleLedgerMaxBytes = STATE_FILE_MAX_DECRYPT_BYTES;
   // ───────────────────────────────────────────────────────────────────────
   // Cron auto-registration
   // ───────────────────────────────────────────────────────────────────────
@@ -334,6 +369,9 @@ var MaintenanceScheduler = class {
       const msg = err instanceof Error ? err.message : String(err);
       log.warn(`qmd maintenance request failed (${reason}): ${msg}`);
     }
+    void this.maybeCompactMemoryLifecycleLedger().catch(
+      (err) => log.debug(`lifecycle ledger auto-compaction check failed (non-fatal): ${err}`)
+    );
   }
   /** Internal: run a single QMD maintenance pass under singleflight guard. */
   async runQmdMaintenance() {
@@ -421,6 +459,359 @@ var MaintenanceScheduler = class {
       }
     }
   }
+  /**
+   * Size-gated, throttled, single-flighted auto-compaction of the lifecycle
+   * ledger (issue #1910). Compacts the root ledger AND every namespace ledger
+   * (`memoryDir/namespaces/<token>/state/`) when namespaces are enabled, each
+   * through the existing `rebuildMemoryLifecycleLedger` so the
+   * archive-then-atomic-write discipline is reused verbatim. `0` disables.
+   *
+   * Before compacting, drain EVERY target's durable pending-append spill (the
+   * root ledger AND each namespace ledger) so a lifecycle event that spilled
+   * while a prior long rewrite held the lock is folded back into its ledger and
+   * cannot be silently lost (issue #2033). Draining is independent of both the
+   * compaction threshold and the min-interval throttle: targets are enumerated
+   * through the same safe (symlink/containment-checked) resolver and every
+   * eligible queue is drained BEFORE any throttle return, so a namespace spill
+   * created after the previous pass never waits out the whole interval.
+   * Encrypted-store safety is preserved — a keyed target drains through its
+   * secure StorageManager, a filesystem-fallback target only through a plaintext
+   * context that refuses encrypted ledgers/spills. Work stays bounded: one
+   * target enumeration plus a bounded per-queue drain.
+   *
+   * The min-interval throttle timestamp advances ONLY after real, fully
+   * successful compaction work: a failed OR deferred target leaves the throttle
+   * un-advanced so it stays eligible on the next maintenance pass, while
+   * `lifecycleCompactionInFlight` still prevents overlapping runs. A "deferred"
+   * target is oversized but could not be compacted because its encrypted ledger
+   * has no unlocked secure store — arming the throttle for it would suppress the
+   * retry of that still-oversized ledger for the whole interval (#2033).
+   *
+   * The min-interval throttle is bypassed for one case: an encrypted ledger
+   * already at/over the whole-file decrypt cap is unreadable, so it must be
+   * clamped on the next pass rather than wait out the interval. Ordinary
+   * below-cap (or plaintext) targets stay throttled (#2033).
+   */
+  async maybeCompactMemoryLifecycleLedger() {
+    const targets = await this.resolveLifecycleCompactionTargets();
+    for (const target of targets) {
+      await this.drainPendingForTarget(target);
+    }
+    const threshold = this.deps.config.memoryLifecycleLedgerCompactBytes;
+    if (!(threshold > 0)) return;
+    if (this.lifecycleCompactionInFlight) return;
+    const now = Date.now();
+    if (now - this.lastLifecycleCompactionAtMs < this.deps.config.memoryLifecycleLedgerCompactMinIntervalMs && !await this.hasOverCapEncryptedLifecycleLedger(targets)) {
+      return;
+    }
+    if (this.lifecycleCompactionInFlight) return;
+    this.lifecycleCompactionInFlight = true;
+    try {
+      let compacted = 0;
+      let failed = 0;
+      let deferred = 0;
+      for (const target of targets) {
+        const outcome = await this.compactLifecycleLedgerTarget(target, threshold);
+        if (outcome === "compacted") compacted += 1;
+        else if (outcome === "failed") failed += 1;
+        else if (outcome === "deferred") deferred += 1;
+      }
+      if (compacted > 0 && failed === 0 && deferred === 0) {
+        this.lastLifecycleCompactionAtMs = now;
+      }
+    } finally {
+      this.lifecycleCompactionInFlight = false;
+    }
+  }
+  /**
+   * True when any lifecycle target's ledger is encrypted at rest AND its
+   * on-disk size is at/over the whole-file decrypt cap. Such a ledger is already
+   * unreadable (the secure reader refuses at/over the cap), so it must reach the
+   * bounded compaction path on the next maintenance pass regardless of the
+   * global min-interval throttle — otherwise the throttle could keep an
+   * unreadable ledger un-clamped for a whole interval (#2033). Ordinary
+   * below-cap or plaintext targets never match, so the throttle still governs
+   * them. A stat/probe failure yields "no forced target" and is left to the
+   * normal compaction path, which classifies it as failed and retries.
+   */
+  async hasOverCapEncryptedLifecycleLedger(targets) {
+    for (const target of targets) {
+      const ledgerPath = path.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+      let size;
+      try {
+        size = (await stat(ledgerPath)).size;
+      } catch {
+        continue;
+      }
+      if (size < this.lifecycleLedgerMaxBytes) continue;
+      try {
+        if (await probeEncryptedRegularFileHeader(ledgerPath)) return true;
+      } catch {
+        continue;
+      }
+    }
+    return false;
+  }
+  /**
+   * Drain one compaction target's durable pending spill. A catalog-backed
+   * target folds through its secure StorageManager; a filesystem-fallback
+   * target (no storage) folds through a path-scoped plaintext context that
+   * refuses encrypted ledgers/spills so a keyless drain never downgrades an
+   * encrypted ledger (issue #2033).
+   */
+  async drainPendingForTarget(target) {
+    if (target.storage) {
+      await this.drainPendingLifecycleAppends(target.storage);
+    } else {
+      await this.drainPendingLifecycleAppendsForPath(target.memoryDir);
+    }
+  }
+  /** Drain a target's durable pending lifecycle-append spill into its ledger
+   *  (issue #2033); non-fatal and a fast no-op when nothing is pending. */
+  async drainPendingLifecycleAppends(storage) {
+    if (!storage) return;
+    try {
+      await storage.drainPendingMemoryLifecycleEvents();
+    } catch (err) {
+      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 = path.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(path.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(path.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
+   * cataloged namespace ledger when namespaces are enabled. Deduplicated by
+   * resolved storage dir so a namespace that collapses onto the root is not
+   * compacted twice. Namespace resolution failures are non-fatal.
+   */
+  async resolveLifecycleCompactionTargets() {
+    const targets = [];
+    const seen = /* @__PURE__ */ new Set();
+    const addTarget = (memoryDir, storage) => {
+      const key = path.resolve(memoryDir);
+      if (seen.has(key)) return;
+      seen.add(key);
+      targets.push({ memoryDir, storage });
+    };
+    const rootStorage = this.deps.getStorage?.();
+    addTarget(rootStorage ? rootStorage.dir : this.deps.config.memoryDir, rootStorage);
+    const resolveNamespaceStorage = this.deps.storageForNamespace;
+    if (resolveNamespaceStorage && this.deps.namespaceCatalog?.enabled) {
+      let records = [];
+      try {
+        records = await this.deps.namespaceCatalog.listNamespaces();
+      } catch (err) {
+        log.debug(`lifecycle compaction: namespace enumeration failed (non-fatal): ${err}`);
+      }
+      for (const record of records) {
+        const namespace = record.namespace.trim();
+        if (!namespace) continue;
+        try {
+          const storage = await resolveNamespaceStorage(namespace);
+          addTarget(storage.dir, storage);
+        } catch (err) {
+          log.debug(
+            `lifecycle compaction: storage resolve failed for namespace ${namespace} (non-fatal): ${err}`
+          );
+        }
+      }
+    }
+    if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
+      const namespacesBase = path.join(this.deps.config.memoryDir, "namespaces");
+      let memoryDirReal;
+      try {
+        memoryDirReal = await realpath(this.deps.config.memoryDir);
+        const baseStat = await lstat(namespacesBase);
+        if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
+          throw new Error("namespaces base is a symlink or not a directory");
+        }
+        assertPathInsideRoot(memoryDirReal, await realpath(namespacesBase), namespacesBase);
+      } catch (err) {
+        if (!isErrnoCode(err, "ENOENT")) {
+          log.debug(`lifecycle compaction: namespaces base rejected (non-fatal): ${err}`);
+        }
+        return targets;
+      }
+      let entries = [];
+      try {
+        entries = await readdir(namespacesBase, { withFileTypes: true });
+      } catch (err) {
+        if (!isErrnoCode(err, "ENOENT")) {
+          log.debug(`lifecycle compaction: namespaces dir scan failed (non-fatal): ${err}`);
+        }
+      }
+      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+        const childPath = path.join(namespacesBase, entry.name);
+        try {
+          assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);
+        } catch (err) {
+          log.debug(`lifecycle compaction: skipping out-of-root namespace dir ${childPath}: ${err}`);
+          continue;
+        }
+        const decodedNamespace = namespaceIdentityFromToken(entry.name);
+        const routeNamespace = decodedNamespace !== null ? decodedNamespace : isSafeRouteNamespace(entry.name) ? entry.name : null;
+        if (resolveNamespaceStorage && routeNamespace !== null) {
+          try {
+            const storage = await resolveNamespaceStorage(routeNamespace);
+            if (path.resolve(storage.dir) === path.resolve(childPath)) {
+              addTarget(storage.dir, storage);
+              continue;
+            }
+            log.debug(
+              `lifecycle compaction: fallback resolver routed ${childPath} to ${storage.dir}; using keyless target`
+            );
+          } catch (err) {
+            log.debug(
+              `lifecycle compaction: fallback storage resolve failed for ${childPath} (non-fatal): ${err}`
+            );
+          }
+        }
+        addTarget(childPath);
+      }
+    }
+    return targets;
+  }
+  /**
+   * Compact one lifecycle ledger when it is at/over `threshold`. Returns
+   * `"skipped"` (absent or below threshold — nothing to do), `"compacted"`
+   * (rewritten and verified under the read/decrypt cap), `"failed"`
+   * (rebuild/probe threw, or the rewritten ledger is STILL over the cap — an
+   * ineffective compaction — non-fatal, retried next pass), or `"deferred"`
+   * (oversized but its encrypted ledger cannot be rewritten because no unlocked
+   * secure store is available — real work still pending, so the caller must NOT
+   * arm the throttle). #2033: a deferred/failed target is distinct from a genuine
+   * no-op so one namespace compacting cannot suppress retries for another, and
+   * an over-cap rewrite never arms the throttle.
+   */
+  async compactLifecycleLedgerTarget(target, threshold) {
+    const ledgerPath = path.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    let size = 0;
+    try {
+      size = (await stat(ledgerPath)).size;
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) return "skipped";
+      log.warn(
+        `lifecycle ledger size check failed (non-fatal) for ${target.memoryDir}: ${err}`
+      );
+      return "failed";
+    }
+    if (size < Math.min(threshold, this.lifecycleLedgerMaxBytes)) return "skipped";
+    let encrypted;
+    try {
+      encrypted = await probeEncryptedRegularFileHeader(ledgerPath);
+    } catch (err) {
+      log.warn(`lifecycle ledger encryption probe failed (non-fatal) for ${ledgerPath}: ${err}`);
+      return "failed";
+    }
+    const effectiveThreshold = encrypted ? Math.min(threshold, this.lifecycleLedgerMaxBytes) : threshold;
+    if (size < effectiveThreshold) return "skipped";
+    if (encrypted && !(target.storage?.isSecureStoreUnlocked() ?? false)) {
+      log.warn(
+        `lifecycle ledger at ${ledgerPath} is encrypted at rest but no unlocked secure storage is available; deferring auto-compaction to avoid a plaintext rewrite. Run 'remnic rebuild-memory-lifecycle-ledger --write' after unlocking.`
+      );
+      return "deferred";
+    }
+    const replacementEncrypted = encrypted || (target.storage?.willEncryptStateWrites() ?? false);
+    const plaintextBudget = replacementEncrypted ? this.lifecycleLedgerMaxBytes - SECURE_STORE_ENVELOPE_OVERHEAD_BYTES - 1 : this.lifecycleLedgerMaxBytes - 1;
+    try {
+      const result = await rebuildMemoryLifecycleLedger({
+        memoryDir: target.memoryDir,
+        dryRun: false,
+        storage: target.storage,
+        // Background compaction must not lose append-only history that
+        // frontmatter cannot reconstruct (issue #1910); the manual CLI repair
+        // rebuild now preserves and bounds identically (#2033).
+        preserveExistingEvents: true,
+        // Bound the PLAINTEXT rewrite to a budget that reserves the secure-store
+        // envelope, so the on-disk ledger (plaintext, or plaintext+envelope when
+        // encrypted) is strictly below the read/decrypt cap; overflow lands in
+        // the verbatim backup (#2033 findings 2+4).
+        maxLedgerBytes: plaintextBudget
+      });
+      let rewrittenSize = 0;
+      try {
+        rewrittenSize = (await stat(ledgerPath)).size;
+      } catch (err) {
+        log.warn(`lifecycle ledger post-compaction size check failed (non-fatal) for ${target.memoryDir}: ${err}`);
+        return "failed";
+      }
+      if (rewrittenSize >= this.lifecycleLedgerMaxBytes) {
+        log.warn(
+          `lifecycle ledger auto-compaction ineffective for ${target.memoryDir}: rewritten ledger is ${rewrittenSize}B, still at/over the ${this.lifecycleLedgerMaxBytes}-byte read/decrypt cap; leaving the throttle un-armed to retry.`
+        );
+        return "failed";
+      }
+      if (result.rewritten === false) {
+        log.debug(
+          `lifecycle ledger already compact for ${target.memoryDir}: ${rewrittenSize}B, no rewrite needed (throttle armed to avoid re-archiving an unchanged ledger).`
+        );
+      } else {
+        log.info(
+          `lifecycle ledger auto-compacted (${target.memoryDir}): ${size}B -> ${rewrittenSize}B, ${result.rebuiltRows} rows (${result.preservedAppendOnlyRows ?? 0} append-only preserved, ${result.archivedOverflowRows ?? 0} overflow archived), backup=${result.backupPath ?? "none"}`
+        );
+      }
+      return "compacted";
+    } catch (err) {
+      log.warn(
+        `lifecycle ledger auto-compaction failed (non-fatal) for ${target.memoryDir}: ${err}`
+      );
+      return "failed";
+    }
+  }
   /** Build the namespace-aware maintenance plan for one job. */
   async namespaceMaintenancePlan(jobName) {
     return planNamespaceMaintenance(this.deps.config, {
@@ -447,4 +838,4 @@ var MaintenanceScheduler = class {
 export {
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-NUWYOKS6.js.map
+//# sourceMappingURL=chunk-MC5Q3J7S.js.map

package/dist/chunk-MC5Q3J7S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/orchestration/maintenance.ts"],"sourcesContent":["/**\n * Maintenance scheduler — extracted from the orchestrator (issue #1526 PR1).\n *\n * Owns the WHEN of memory maintenance:\n *   - cron auto-registration (writes jobs.json entries the OpenClaw cron\n *     daemon picks up)\n *   - debounced + singleflight QMD index maintenance (re-index + embed\n *     after writes)\n *   - consolidation scheduling trigger (count + interval gated)\n *\n * Does NOT own the WHAT — the actual job runners (runSemanticConsolidation,\n * runPatternReinforcement, runDeepSleepGovernanceNow, runConsolidation)\n * remain on the orchestrator because they need the full LLM + extraction\n * dependency surface. The scheduler invokes consolidation through a\n * callback so the orchestrator stays the source of truth for that work.\n *\n * Behavior-preserving move from orchestrator.ts. No logic changes — the\n * orchestrator keeps thin delegating methods so existing tests that stub\n * `orchestrator.requestQmdMaintenance` etc. continue to work.\n */\n\nimport { resolveNamespaceCapabilities,\n  resolveQmdCapabilities,resolveConsolidationCapabilities, resolveRecallAuxiliaryCapabilities } from \"../capabilities.js\";\nimport { existsSync, type Dirent } from \"node:fs\";\nimport { appendFile, lstat, mkdir, readFile, readdir, realpath, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\nimport type { PluginConfig } from \"../types.js\";\nimport type { SearchBackend } from \"../search/port.js\";\nimport type { StorageManager } from \"../index.js\";\nimport {\n  NamespaceSearchRouter,\n  type NamespaceUpdateResult,\n} from \"../namespaces/search.js\";\nimport type { NamespaceCatalog, NamespaceRecord } from \"../namespaces/catalog.js\";\nimport { namespaceIdentityFromToken } from \"../namespaces/identity.js\";\nimport { isSafeRouteNamespace } from \"../routing/engine.js\";\nimport {\n  planNamespaceMaintenance,\n  runNamespaceMaintenanceBatchPlan,\n  type NamespaceMaintenancePlan,\n  type NamespaceMaintenanceSkipReason,\n} from \"../maintenance/namespace-planner.js\";\nimport {\n  ensureContradictionScanCron,\n  ensureDaySummaryCron,\n  ensureGraphEdgeDecayCron,\n  ensureNightlyGovernanceCron,\n  ensurePatternReinforcementCron,\n  ensureProceduralMiningCron,\n  graphEdgeDecayCadenceToCronExpr,\n} from \"../maintenance/memory-governance-cron.js\";\nimport { rebuildMemoryLifecycleLedger } from \"../maintenance/rebuild-memory-lifecycle-ledger.js\";\nimport {\n  drainPendingLifecycleLedgerIfAny,\n  pendingLifecycleLedgerDir,\n  type LifecyclePendingIo,\n} from \"../storage/memory-lifecycle-ledger-access.js\";\nimport { STATE_FILE_MAX_DECRYPT_BYTES } from \"../storage/secure-line-reader.js\";\nimport { resolveHomeDir } from \"../runtime/env.js\";\nimport { log } from \"../logger.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\nimport { assertPathInsideRoot, listContainedSpillFiles } from \"../utils/path-containment.js\";\nimport {\n  probeEncryptedRegularFileHeader,\n  SECURE_STORE_ENVELOPE_OVERHEAD_BYTES,\n} from \"../secure-store/secure-fs.js\";\n\n/** Reason a QMD maintenance pass was skipped, used for status recording. */\nfunction qmdMaintenanceSkipReasonForError(\n  error: unknown,\n): NamespaceMaintenanceSkipReason | null {\n  const message = error instanceof Error ? error.message : String(error);\n  return /^QMD (?:update|embed) skipped by .*min-interval gate$/.test(message)\n    ? \"throttled\"\n    : null;\n}\n\n/** Dependencies injected by the orchestrator. All stable references. */\nexport interface MaintenanceSchedulerDeps {\n  config: PluginConfig;\n  /** Live accessor — the orchestrator can reassign its qmd backend after\n   *  construction (e.g. swap to NoopSearchBackend when the collection is\n   *  missing), and the scheduler must always observe the current backend. */\n  getQmd: () => SearchBackend;\n  namespaceSearchRouter: NamespaceSearchRouter;\n  namespaceCatalog: NamespaceCatalog;\n  /**\n   * Root storage (secure-store configured). Threaded so lifecycle-ledger\n   * auto-compaction (#1910) rebuilds through the live secure context: encrypted\n   * memories stay decryptable and the rewritten ledger stays encrypted at rest.\n   * Omitted in focused tests, where compaction falls back to a fresh plaintext\n   * StorageManager (the CLI-equivalent path).\n   */\n  getStorage?: () => StorageManager;\n  /**\n   * Resolve a namespace's (secure-store aware) storage. Threaded so\n   * auto-compaction also bounds per-namespace lifecycle ledgers under\n   * `memoryDir/namespaces/<token>/state/`, not just the root state path\n   * (#1910). Consulted only when namespaces are enabled.\n   */\n  storageForNamespace?: (namespace: string) => Promise<StorageManager>;\n}\n\n/**\n * Schedules and debounces memory maintenance work. Owns the cadence +\n * singleflight state that previously lived as private orchestrator fields.\n *\n * The orchestrator constructs one instance in its constructor and delegates\n * the public scheduling entrypoints to it. Job execution stays on the\n * orchestrator (LLM-heavy) and is invoked through callbacks.\n */\nexport class MaintenanceScheduler {\n  // ── Consolidation scheduling state ──\n  private nonZeroExtractionsSinceConsolidation = 0;\n  private lastConsolidationRunAtMs = 0;\n  private consolidationInFlight = false;\n\n  // ── QMD maintenance scheduling state ──\n  private qmdMaintenanceTimer: NodeJS.Timeout | null = null;\n  private qmdMaintenancePending = false;\n  private qmdMaintenanceInFlight = false;\n  private lastQmdEmbedAtMs = 0;\n  private lastQmdEmbedAtMsByNamespace = new Map<string, number>();\n\n  // ── Lifecycle-ledger auto-compaction state (issue #1910) ──\n  private lifecycleCompactionInFlight = false;\n  private lastLifecycleCompactionAtMs = 0;\n  // Upper bound on a rewritten ledger; a preserving compaction is bounded to\n  // this so it can never leave the ledger over the whole-file read/decrypt cap\n  // (#2033). Defaults to the decrypt cap; overridable in focused tests to drive\n  // the bounding + post-write verification deterministically without a 400MB\n  // fixture.\n  private lifecycleLedgerMaxBytes = STATE_FILE_MAX_DECRYPT_BYTES;\n\n  constructor(private readonly deps: MaintenanceSchedulerDeps) {}\n\n  // ───────────────────────────────────────────────────────────────────────\n  // Cron auto-registration\n  // ───────────────────────────────────────────────────────────────────────\n\n  /**\n   * Register every cron job the daemon should run, gated by its config flag.\n   * Each registration is independent and non-fatal — a failure in one does\n   * not block the others (mirrors the orchestrator's prior sequential try/\n   * catch behavior exactly).\n   *\n   * Returns when all eligible registrations have completed so callers that\n   * `await deferredReady` can rely on jobs.json being current.\n   */\n  async autoRegisterCrons(_signal: AbortSignal): Promise<void> {\n    if (resolveRecallAuxiliaryCapabilities(this.deps.config).daySummary) {\n      try {\n        await this.autoRegisterDaySummaryCron();\n      } catch (err) {\n        log.debug(`day-summary cron auto-register failed (non-fatal): ${err}`);\n      }\n    }\n    if (this.deps.config.nightlyGovernanceCronAutoRegister) {\n      try {\n        await this.autoRegisterNightlyGovernanceCron();\n      } catch (err) {\n        log.debug(`nightly governance cron auto-register failed (non-fatal): ${err}`);\n      }\n    }\n    if (this.deps.config.procedural?.proceduralMiningCronAutoRegister) {\n      try {\n        await this.autoRegisterProceduralMiningCron();\n      } catch (err) {\n        log.debug(`procedural mining cron auto-register failed (non-fatal): ${err}`);\n      }\n    }\n    if (this.deps.config.contradictionScan?.enabled) {\n      try {\n        await this.autoRegisterContradictionScanCron();\n      } catch (err) {\n        log.debug(`contradiction scan cron auto-register failed (non-fatal): ${err}`);\n      }\n    }\n    if (resolveConsolidationCapabilities(this.deps.config).patternReinforcement) {\n      try {\n        await this.autoRegisterPatternReinforcementCron();\n      } catch (err) {\n        log.debug(`pattern reinforcement cron auto-register failed (non-fatal): ${err}`);\n      }\n    }\n    if (resolveConsolidationCapabilities(this.deps.config).graphEdgeDecay) {\n      try {\n        await this.autoRegisterGraphEdgeDecayCron();\n      } catch (err) {\n        log.debug(`graph edge decay cron auto-register failed (non-fatal): ${err}`);\n      }\n    }\n  }\n\n  async autoRegisterDaySummaryCron(): Promise<void> {\n    const home = resolveHomeDir();\n    const jobsPath = path.join(home, \".openclaw\", \"cron\", \"jobs.json\");\n\n    try {\n      if (!existsSync(jobsPath)) {\n        log.debug(\"day-summary cron: jobs.json not found, skipping auto-register\");\n        return;\n      }\n\n      // Resolve an OpenClaw cron-routing model only in gateway mode. In plugin\n      // mode, summaryModel is a direct-client model id for Remnic's own LLM\n      // calls and may be unroutable as an OpenClaw agentTurn model.\n      const rawSummaryModel = this.deps.config.summaryModel;\n      const taskPrimary = this.deps.config.taskModelChain?.primary;\n      const isGateway = this.deps.config.modelSource === \"gateway\";\n      const model = isGateway ? (rawSummaryModel || taskPrimary || undefined) : undefined;\n      // Attach task-chain fallbacks only when the model matches the task-chain\n      // primary. If summaryModel is a distinct override, its fallbacks would\n      // be unrelated to the task chain. Also append gateway default models as\n      // tail fallbacks (de-duped) so a task-chain outage doesn't stop the cron\n      // before reaching the gateway default chain. Mirrors hourly cron pattern.\n      const fallbacks: string[] = [];\n      if (model && taskPrimary && model === taskPrimary) {\n        const seen = new Set<string>(model ? [model] : []);\n        const addUnique = (value: string | undefined) => {\n          if (typeof value !== \"string\") return;\n          const trimmed = value.trim();\n          if (trimmed.length > 0 && !seen.has(trimmed)) {\n            seen.add(trimmed);\n            fallbacks.push(trimmed);\n          }\n        };\n        for (const fb of this.deps.config.taskModelChain?.fallbacks ?? []) addUnique(fb);\n        const gwDefaults = this.deps.config.gatewayConfig?.agents?.defaults?.model;\n        addUnique(gwDefaults?.primary);\n        if (Array.isArray(gwDefaults?.fallbacks)) {\n          for (const fb of gwDefaults.fallbacks) addUnique(fb);\n        }\n      }\n\n      const timezone =\n        this.deps.config.daySummaryTimezone ||\n        Intl.DateTimeFormat().resolvedOptions().timeZone;\n\n      const result = await ensureDaySummaryCron(jobsPath, {\n        timezone,\n        ...(model ? { model } : {}),\n        ...(fallbacks.length > 0 ? { fallbacks } : {}),\n      });\n      if (result.created) {\n        log.info(\n          `day-summary cron auto-registered (${result.jobId}, 23:47 ${timezone}${model ? `, model: ${model}` : \"\"})`,\n        );\n      } else if (result.updated) {\n        log.info(\n          `day-summary cron reconciled (${result.jobId}, timezone: ${timezone}${model ? `, model: ${model}` : \"\"})`,\n        );\n      } else {\n        log.debug(\"day-summary cron already up to date\");\n      }\n    } catch (err) {\n      log.debug(`day-summary cron auto-register error: ${err}`);\n    }\n  }\n\n  async autoRegisterNightlyGovernanceCron(): Promise<void> {\n    const home = resolveHomeDir();\n    const jobsPath = path.join(home, \".openclaw\", \"cron\", \"jobs.json\");\n\n    try {\n      if (!existsSync(jobsPath)) {\n        log.debug(\"nightly governance cron: jobs.json not found, skipping auto-register\");\n        return;\n      }\n\n      const created = await ensureNightlyGovernanceCron(jobsPath, {\n        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n      });\n      if (created.created) {\n        log.info(\n          `nightly governance cron auto-registered (${created.jobId}, 02:23 ${Intl.DateTimeFormat().resolvedOptions().timeZone})`,\n        );\n      } else {\n        log.debug(\"nightly governance cron already exists, skipping auto-register\");\n      }\n    } catch (err) {\n      log.debug(`nightly governance cron auto-register error: ${err}`);\n    }\n  }\n\n  async autoRegisterProceduralMiningCron(): Promise<void> {\n    const home = resolveHomeDir();\n    const jobsPath = path.join(home, \".openclaw\", \"cron\", \"jobs.json\");\n    try {\n      if (!existsSync(jobsPath)) {\n        log.debug(\"procedural mining cron: jobs.json not found, skipping auto-register\");\n        return;\n      }\n      const created = await ensureProceduralMiningCron(jobsPath, {\n        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n      });\n      if (created.created) {\n        log.info(`procedural mining cron auto-registered (${created.jobId})`);\n      } else {\n        log.debug(\"procedural mining cron already exists, skipping auto-register\");\n      }\n    } catch (err) {\n      log.debug(`procedural mining cron auto-register error: ${err}`);\n    }\n  }\n\n  async autoRegisterContradictionScanCron(): Promise<void> {\n    const home = resolveHomeDir();\n    const jobsPath = path.join(home, \".openclaw\", \"cron\", \"jobs.json\");\n    try {\n      if (!existsSync(jobsPath)) {\n        log.debug(\"contradiction scan cron: jobs.json not found, skipping auto-register\");\n        return;\n      }\n      const created = await ensureContradictionScanCron(jobsPath, {\n        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n      });\n      if (created.created) {\n        log.info(`contradiction scan cron auto-registered (${created.jobId})`);\n      } else {\n        log.debug(\"contradiction scan cron already exists, skipping auto-register\");\n      }\n    } catch (err) {\n      log.debug(`contradiction scan cron auto-register error: ${err}`);\n    }\n  }\n\n  async autoRegisterPatternReinforcementCron(): Promise<void> {\n    const home = resolveHomeDir();\n    const jobsPath = path.join(home, \".openclaw\", \"cron\", \"jobs.json\");\n    try {\n      if (!existsSync(jobsPath)) {\n        log.debug(\"pattern reinforcement cron: jobs.json not found, skipping auto-register\");\n        return;\n      }\n      const created = await ensurePatternReinforcementCron(jobsPath, {\n        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n      });\n      if (created.created) {\n        log.info(`pattern reinforcement cron auto-registered (${created.jobId})`);\n      } else {\n        log.debug(\"pattern reinforcement cron already exists, skipping auto-register\");\n      }\n    } catch (err) {\n      log.debug(`pattern reinforcement cron auto-register error: ${err}`);\n    }\n  }\n\n  async autoRegisterGraphEdgeDecayCron(): Promise<void> {\n    const home = resolveHomeDir();\n    const jobsPath = path.join(home, \".openclaw\", \"cron\", \"jobs.json\");\n    try {\n      if (!existsSync(jobsPath)) {\n        log.debug(\"graph edge decay cron: jobs.json not found, skipping auto-register\");\n        return;\n      }\n      const scheduleExpr = graphEdgeDecayCadenceToCronExpr(\n        this.deps.config.graphEdgeDecayCadenceMs,\n      );\n      const created = await ensureGraphEdgeDecayCron(jobsPath, {\n        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n        scheduleExpr,\n      });\n      if (created.created) {\n        log.info(`graph edge decay cron auto-registered (${created.jobId}, ${scheduleExpr})`);\n      } else {\n        log.debug(\"graph edge decay cron already exists, skipping auto-register\");\n      }\n    } catch (err) {\n      log.debug(`graph edge decay cron auto-register error: ${err}`);\n    }\n  }\n\n  // ───────────────────────────────────────────────────────────────────────\n  // Consolidation scheduling\n  // ───────────────────────────────────────────────────────────────────────\n\n  /**\n   * Maybe trigger a background consolidation pass after an extraction.\n   * Counted + interval gated so a burst of extractions does not fan into a\n   * burst of consolidation passes. The consolidation runner itself is\n   * passed in as a callback because it lives on the orchestrator (LLM +\n   * storage dependency surface) and is not owned by this module.\n   */\n  maybeScheduleConsolidation(\n    nonZeroExtraction: boolean,\n    runConsolidation: () => Promise<unknown>,\n  ): void {\n    if (nonZeroExtraction) this.nonZeroExtractionsSinceConsolidation += 1;\n    if (\n      this.deps.config.consolidationRequireNonZeroExtraction &&\n      !nonZeroExtraction\n    ) {\n      return;\n    }\n    if (\n      this.nonZeroExtractionsSinceConsolidation <\n      this.deps.config.consolidateEveryN\n    ) {\n      return;\n    }\n\n    const now = Date.now();\n    if (\n      now - this.lastConsolidationRunAtMs <\n      this.deps.config.consolidationMinIntervalMs\n    ) {\n      return;\n    }\n    if (this.consolidationInFlight) return;\n\n    this.consolidationInFlight = true;\n    this.lastConsolidationRunAtMs = now;\n    this.nonZeroExtractionsSinceConsolidation = 0;\n    runConsolidation()\n      .catch((err) => log.error(\"background consolidation failed\", err))\n      .finally(() => {\n        this.consolidationInFlight = false;\n      });\n  }\n\n  /** Whether a background consolidation pass is currently running. Exposed so\n   *  the orchestrator's waitForConsolidationIdle can poll idle state without\n   *  owning the cadence state (issue #1526 PR1). */\n  isConsolidationInFlight(): boolean {\n    return this.consolidationInFlight;\n  }\n\n  /** Whether a debounced QMD maintenance pass is armed and waiting for the\n   *  debounce timer. Exposed so drain/teardown diagnostics (e.g. the bench\n   *  adapter) can observe scheduler idle state after the #1526 PR1 extraction\n   *  moved this flag off the orchestrator. */\n  isQmdMaintenancePending(): boolean {\n    return this.qmdMaintenancePending;\n  }\n\n  /** Whether a QMD maintenance pass is currently running (singleflight guard).\n   *  Exposed for drain/teardown diagnostics (see isQmdMaintenancePending). */\n  isQmdMaintenanceInFlight(): boolean {\n    return this.qmdMaintenanceInFlight;\n  }\n  // ───────────────────────────────────────────────────────────────────────\n  // QMD maintenance scheduling (debounced + singleflight)\n  // ───────────────────────────────────────────────────────────────────────\n\n  /** Internal: queue a debounced QMD maintenance pass. */\n  private requestQmdMaintenance(): void {\n    if (!this.deps.getQmd().isAvailable()) return;\n    if (!resolveQmdCapabilities(this.deps.config).qmdMaintenance) return;\n\n    this.qmdMaintenancePending = true;\n    if (this.qmdMaintenanceTimer) return;\n\n    this.qmdMaintenanceTimer = setTimeout(() => {\n      this.qmdMaintenanceTimer = null;\n      this.runQmdMaintenance().catch((err) =>\n        log.debug(`background qmd maintenance failed: ${err}`),\n      );\n    }, this.deps.config.qmdMaintenanceDebounceMs);\n  }\n\n  /**\n   * Public entrypoint for tool-driven QMD maintenance requests.\n   * Routes through existing debounced/singleflight maintenance controls.\n   */\n  requestQmdMaintenanceForTool(reason: string): void {\n    try {\n      this.requestQmdMaintenance();\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err);\n      log.warn(`qmd maintenance request failed (${reason}): ${msg}`);\n    }\n    // Lifecycle-ledger auto-compaction (#1910) must run independently of QMD.\n    // When QMD is unavailable or its maintenance capability is off,\n    // requestQmdMaintenance() short-circuits and runQmdMaintenance() never\n    // fires — so a compaction check living only in that path would never run.\n    // Fire it here on every maintenance request (throttled, size-gated,\n    // single-flighted, never awaited, never throws) so a QMD-off deployment\n    // still bounds the lifecycle ledger.\n    void this.maybeCompactMemoryLifecycleLedger().catch((err) =>\n      log.debug(`lifecycle ledger auto-compaction check failed (non-fatal): ${err}`),\n    );\n  }\n\n  /** Internal: run a single QMD maintenance pass under singleflight guard. */\n  async runQmdMaintenance(): Promise<void> {\n    if (this.qmdMaintenanceInFlight) return;\n    if (!this.qmdMaintenancePending) return;\n    this.qmdMaintenanceInFlight = true;\n    this.qmdMaintenancePending = false;\n\n    try {\n      if (resolveNamespaceCapabilities(this.deps.config).namespaces) {\n        // Include cataloged dynamic namespaces, not just the configured set\n        // (NGnei), but run through the namespace-aware maintenance planner so\n        // each namespace is budgeted, lock-protected, and status-recorded\n        // independently (issue #1500).\n        const plan = await this.namespaceMaintenancePlan(\"qmd\");\n        const now = Date.now();\n        const lastEmbedAtByNamespace = this.lastQmdEmbedAtMsByNamespace;\n        const dueEmbedNamespaces = (namespaces: string[]): string[] => {\n          if (!resolveQmdCapabilities(this.deps.config).qmdAutoEmbed) return [];\n          return namespaces.filter(\n            (namespace) =>\n              now - (lastEmbedAtByNamespace.get(namespace) ?? 0) >=\n              this.deps.config.qmdEmbedMinIntervalMs,\n          );\n        };\n        const markEmbedded = (namespaces: string[]): void => {\n          if (namespaces.length === 0) return;\n          for (const namespace of namespaces) {\n            lastEmbedAtByNamespace.set(namespace, now);\n          }\n          this.lastQmdEmbedAtMs = now;\n        };\n        await runNamespaceMaintenanceBatchPlan(\n          this.deps.config,\n          plan,\n          async (candidates) => {\n            const namespaces = candidates.map((candidate) => candidate.namespace);\n            const embedNamespaces = dueEmbedNamespaces(namespaces);\n            let result: NamespaceUpdateResult;\n            try {\n              result = await this.deps.namespaceSearchRouter.updateNamespacesDetailed(\n                namespaces,\n                undefined,\n                { strict: true },\n              );\n            } catch (error) {\n              if (\n                embedNamespaces.length > 0 &&\n                qmdMaintenanceSkipReasonForError(error) === \"throttled\"\n              ) {\n                await this.deps.namespaceSearchRouter.embedNamespaces(embedNamespaces, {\n                  strict: true,\n                });\n                markEmbedded(embedNamespaces);\n              }\n              throw error;\n            }\n            if (result.backendCount <= 0) {\n              throw new Error(\"no eligible QMD backend for selected namespaces\");\n            }\n            if (result.eligibleNamespaces.length !== namespaces.length) {\n              const eligible = new Set(result.eligibleNamespaces);\n              const missing = namespaces.filter(\n                (namespace) => !eligible.has(namespace),\n              );\n              throw new Error(\n                `QMD backend ineligible for selected namespaces (${missing.length})`,\n              );\n            }\n            if (embedNamespaces.length > 0) {\n              await this.deps.namespaceSearchRouter.embedNamespaces(embedNamespaces, {\n                strict: true,\n              });\n              markEmbedded(embedNamespaces);\n            }\n            return { itemCount: result.backendCount };\n          },\n          this.deps.namespaceCatalog,\n          {\n            skipReasonForError: qmdMaintenanceSkipReasonForError,\n          },\n        );\n      } else {\n        await this.deps.getQmd().update();\n        const now = Date.now();\n        if (\n          resolveQmdCapabilities(this.deps.config).qmdAutoEmbed &&\n          now - this.lastQmdEmbedAtMs >= this.deps.config.qmdEmbedMinIntervalMs\n        ) {\n          await this.deps.getQmd().embed();\n          this.lastQmdEmbedAtMs = now;\n        }\n      }\n      // Note: a successful QMD update/embed clears the global QMD result caches\n      // itself (QmdClient.runUpdateForCollection / runEmbedForCollection), so\n      // this scheduler does not invalidate them here — every refresh path\n      // (direct update, namespace router, wearable/OpenClaw sync) funnels through\n      // the backend and clears centrally. A no-op pass (throttle/unavailable/\n      // backoff) does not advance lastUpdateRanAtMs, so it leaves caches warm\n      // (#1904, Codex/Cursor).\n    } finally {\n      this.qmdMaintenanceInFlight = false;\n      if (this.qmdMaintenancePending) {\n        this.requestQmdMaintenance();\n      }\n      // Lifecycle-ledger auto-compaction is triggered from\n      // requestQmdMaintenanceForTool (every maintenance request, QMD or not),\n      // so it does not need to be re-fired here (issue #1910).\n    }\n  }\n\n  /**\n   * Size-gated, throttled, single-flighted auto-compaction of the lifecycle\n   * ledger (issue #1910). Compacts the root ledger AND every namespace ledger\n   * (`memoryDir/namespaces/<token>/state/`) when namespaces are enabled, each\n   * through the existing `rebuildMemoryLifecycleLedger` so the\n   * archive-then-atomic-write discipline is reused verbatim. `0` disables.\n   *\n   * Before compacting, drain EVERY target's durable pending-append spill (the\n   * root ledger AND each namespace ledger) so a lifecycle event that spilled\n   * while a prior long rewrite held the lock is folded back into its ledger and\n   * cannot be silently lost (issue #2033). Draining is independent of both the\n   * compaction threshold and the min-interval throttle: targets are enumerated\n   * through the same safe (symlink/containment-checked) resolver and every\n   * eligible queue is drained BEFORE any throttle return, so a namespace spill\n   * created after the previous pass never waits out the whole interval.\n   * Encrypted-store safety is preserved — a keyed target drains through its\n   * secure StorageManager, a filesystem-fallback target only through a plaintext\n   * context that refuses encrypted ledgers/spills. Work stays bounded: one\n   * target enumeration plus a bounded per-queue drain.\n   *\n   * The min-interval throttle timestamp advances ONLY after real, fully\n   * successful compaction work: a failed OR deferred target leaves the throttle\n   * un-advanced so it stays eligible on the next maintenance pass, while\n   * `lifecycleCompactionInFlight` still prevents overlapping runs. A \"deferred\"\n   * target is oversized but could not be compacted because its encrypted ledger\n   * has no unlocked secure store — arming the throttle for it would suppress the\n   * retry of that still-oversized ledger for the whole interval (#2033).\n   *\n   * The min-interval throttle is bypassed for one case: an encrypted ledger\n   * already at/over the whole-file decrypt cap is unreadable, so it must be\n   * clamped on the next pass rather than wait out the interval. Ordinary\n   * below-cap (or plaintext) targets stay throttled (#2033).\n   */\n  private async maybeCompactMemoryLifecycleLedger(): Promise<void> {\n    // Enumerate every lifecycle target (root + namespaces) through the safe,\n    // containment-checked resolver, and fold each one's durable pending spill\n    // back into its ledger BEFORE any threshold or throttle return (#2033). A\n    // spill created after the previous pass must land promptly even while\n    // compaction is throttled or disabled; draining is bounded per queue and\n    // never bypasses encrypted-store safety.\n    const targets = await this.resolveLifecycleCompactionTargets();\n    for (const target of targets) {\n      await this.drainPendingForTarget(target);\n    }\n\n    const threshold = this.deps.config.memoryLifecycleLedgerCompactBytes;\n    if (!(threshold > 0)) return; // 0 / negative / non-numeric disables compaction.\n    if (this.lifecycleCompactionInFlight) return;\n    const now = Date.now();\n    if (\n      now - this.lastLifecycleCompactionAtMs <\n        this.deps.config.memoryLifecycleLedgerCompactMinIntervalMs &&\n      !(await this.hasOverCapEncryptedLifecycleLedger(targets))\n    ) {\n      // Throttled: no ordinary target is due yet. The exception is an encrypted\n      // ledger already at/over the whole-file decrypt cap — it is unreadable, so\n      // the global min-interval must not defer clamping it for a whole interval.\n      // The guard above lets such a target through immediately (compaction then\n      // clamps it via the cap-aware effective threshold) while ordinary\n      // below-cap targets stay throttled (#2033).\n      return;\n    }\n    // The over-cap probe above awaits, so a second maintenance request can pass\n    // the early `lifecycleCompactionInFlight` guard and reach here during that\n    // await. Recheck the guard immediately before claiming it — otherwise two\n    // racing requests both see an over-cap ledger and run duplicate 400MB-class\n    // compactions/backups back-to-back (#2033). The set below is synchronous\n    // with this recheck (no await between), so exactly one caller wins.\n    if (this.lifecycleCompactionInFlight) return;\n    this.lifecycleCompactionInFlight = true;\n    try {\n      let compacted = 0;\n      let failed = 0;\n      let deferred = 0;\n      for (const target of targets) {\n        const outcome = await this.compactLifecycleLedgerTarget(target, threshold);\n        if (outcome === \"compacted\") compacted += 1;\n        else if (outcome === \"failed\") failed += 1;\n        else if (outcome === \"deferred\") deferred += 1;\n      }\n      // Arm the throttle only when at least one ledger actually compacted AND\n      // nothing failed AND nothing was deferred. A below-threshold no-op\n      // (compacted === 0), any failure, or a deferred oversized ledger (locked\n      // encrypted store, still pending) leaves the throttle where it was so the\n      // next pass retries the untouched targets (#2033).\n      if (compacted > 0 && failed === 0 && deferred === 0) {\n        this.lastLifecycleCompactionAtMs = now;\n      }\n    } finally {\n      this.lifecycleCompactionInFlight = false;\n    }\n  }\n\n  /**\n   * True when any lifecycle target's ledger is encrypted at rest AND its\n   * on-disk size is at/over the whole-file decrypt cap. Such a ledger is already\n   * unreadable (the secure reader refuses at/over the cap), so it must reach the\n   * bounded compaction path on the next maintenance pass regardless of the\n   * global min-interval throttle — otherwise the throttle could keep an\n   * unreadable ledger un-clamped for a whole interval (#2033). Ordinary\n   * below-cap or plaintext targets never match, so the throttle still governs\n   * them. A stat/probe failure yields \"no forced target\" and is left to the\n   * normal compaction path, which classifies it as failed and retries.\n   */\n  private async hasOverCapEncryptedLifecycleLedger(\n    targets: Array<{ memoryDir: string; storage?: StorageManager }>,\n  ): Promise<boolean> {\n    for (const target of targets) {\n      const ledgerPath = path.join(target.memoryDir, \"state\", \"memory-lifecycle-ledger.jsonl\");\n      let size: number;\n      try {\n        size = (await stat(ledgerPath)).size;\n      } catch {\n        continue; // absent/unstattable — nothing to force here.\n      }\n      if (size < this.lifecycleLedgerMaxBytes) continue;\n      try {\n        if (await probeEncryptedRegularFileHeader(ledgerPath)) return true;\n      } catch {\n        continue; // probe failure — the normal compaction path reports it.\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Drain one compaction target's durable pending spill. A catalog-backed\n   * target folds through its secure StorageManager; a filesystem-fallback\n   * target (no storage) folds through a path-scoped plaintext context that\n   * refuses encrypted ledgers/spills so a keyless drain never downgrades an\n   * encrypted ledger (issue #2033).\n   */\n  private async drainPendingForTarget(\n    target: { memoryDir: string; storage?: StorageManager },\n  ): Promise<void> {\n    if (target.storage) {\n      await this.drainPendingLifecycleAppends(target.storage);\n    } else {\n      await this.drainPendingLifecycleAppendsForPath(target.memoryDir);\n    }\n  }\n\n  /** Drain a target's durable pending lifecycle-append spill into its ledger\n   *  (issue #2033); non-fatal and a fast no-op when nothing is pending. */\n  private async drainPendingLifecycleAppends(storage: StorageManager | undefined): Promise<void> {\n    if (!storage) return;\n    try {\n      await storage.drainPendingMemoryLifecycleEvents();\n    } catch (err) {\n      log.debug(`lifecycle pending drain failed (non-fatal): ${err}`);\n    }\n  }\n\n  /**\n   * Drain a filesystem-fallback target's pending lifecycle-append spill when no\n   * secure StorageManager is available (catalog-disabled namespace; issue\n   * #2033). Uses the safe path-scoped PLAINTEXT context this fallback already\n   * operates in: a keyless drain can only fold plaintext spills into a plaintext\n   * ledger, so it refuses when the ledger or ANY spill is encrypted at rest,\n   * leaving those pending for a keyed (catalog-path) drain — exactly mirroring\n   * the fallback compaction's encrypted-ledger deferral. Non-fatal; a fast\n   * no-op when nothing is pending. The shared spill lister enforces the symlink/\n   * containment guard on every spill file it reads or deletes.\n   */\n  private async drainPendingLifecycleAppendsForPath(memoryDir: string): Promise<void> {\n    const ledgerPath = path.join(memoryDir, \"state\", \"memory-lifecycle-ledger.jsonl\");\n    const spillDir = pendingLifecycleLedgerDir(ledgerPath);\n    // Enumerate spills through the SAME guarded lister the actual drain uses\n    // (listContainedSpillFiles): it rejects a symlinked/non-directory spill dir\n    // and skips any symlink/FIFO/device/escaping entry, returning only regular\n    // files contained in the dir. Never raw-readdir + open() an untrusted name:\n    // opening a FIFO would block until a writer appears and a symlink would\n    // redirect the probe outside the dir (#2033). Enumerate BOTH live `*.jsonl`\n    // spills and crash-orphaned `*.jsonl.claimed` files: a drain that died\n    // between claiming a spill (rename to `.claimed`) and committing it leaves\n    // the ONLY copy of those rows as a claimed orphan. Gating solely on live\n    // spills would early-return here whenever the pending dir holds nothing but\n    // orphans, stranding those rows forever; proceeding lets\n    // drainPendingLifecycleLedgerIfAny -> recoverOrphanedClaims restore and\n    // re-commit them under the ledger lock (#2033).\n    let spillFiles: string[];\n    let claimedOrphans: string[];\n    try {\n      spillFiles = await listContainedSpillFiles(spillDir);\n      claimedOrphans = await listContainedSpillFiles(spillDir, \".jsonl.claimed\");\n    } catch (err) {\n      log.debug(`fallback lifecycle pending scan failed (non-fatal) for ${memoryDir}: ${err}`);\n      return;\n    }\n    if (spillFiles.length === 0 && claimedOrphans.length === 0) return;\n    // The pending encryption state is authoritative only UNDER the ledger lock:\n    // drainPendingLifecycleLedgerIfAny waits for the lock and re-enumerates the\n    // pending dir, so a secure-store writer that spills an encrypted file — or a\n    // keyed compaction that rewrites the ledger encrypted — while this fallback\n    // waits would defeat any pre-lock probe (#2033). Probe each file at the\n    // moment of use inside the held lock instead: readSecure refuses an\n    // encrypted spill (the fold reads each spill lazily and propagates the throw\n    // BEFORE claiming that spill, leaving it intact) and the append refuses a\n    // ledger that became encrypted (the fold rolls the claims back). Either way\n    // the plaintext IO\n    // never reads or writes ciphertext; the keyed catalog-path drain handles the\n    // deferred rows.\n    const io: LifecyclePendingIo = {\n      writeSecure: async (filePath, payload) => {\n        await mkdir(path.dirname(filePath), { recursive: true });\n        await writeFile(filePath, payload, \"utf-8\");\n      },\n      readSecure: async (filePath) => {\n        if (await probeEncryptedRegularFileHeader(filePath)) {\n          throw new Error(`fallback lifecycle drain deferred: encrypted spill at ${filePath}`);\n        }\n        return readFile(filePath, \"utf-8\");\n      },\n    };\n    try {\n      await drainPendingLifecycleLedgerIfAny(\n        ledgerPath,\n        io,\n        async (payload) => {\n          if (await probeEncryptedRegularFileHeader(ledgerPath)) {\n            throw new Error(`fallback lifecycle drain deferred: ledger became encrypted at ${ledgerPath}`);\n          }\n          await appendFile(ledgerPath, payload, \"utf-8\");\n        },\n        async () => {\n          await mkdir(path.dirname(ledgerPath), { recursive: true });\n        },\n      );\n    } catch (err) {\n      log.debug(`fallback lifecycle pending drain failed (non-fatal) for ${memoryDir}: ${err}`);\n    }\n  }\n\n  /**\n   * Enumerate the lifecycle ledgers to consider for compaction: the root\n   * (through the secure-configured root storage when available) plus every\n   * cataloged namespace ledger when namespaces are enabled. Deduplicated by\n   * resolved storage dir so a namespace that collapses onto the root is not\n   * compacted twice. Namespace resolution failures are non-fatal.\n   */\n  private async resolveLifecycleCompactionTargets(): Promise<\n    Array<{ memoryDir: string; storage?: StorageManager }>\n  > {\n    const targets: Array<{ memoryDir: string; storage?: StorageManager }> = [];\n    const seen = new Set<string>();\n    const addTarget = (memoryDir: string, storage?: StorageManager): void => {\n      const key = path.resolve(memoryDir);\n      if (seen.has(key)) return;\n      seen.add(key);\n      targets.push({ memoryDir, storage });\n    };\n\n    const rootStorage = this.deps.getStorage?.();\n    addTarget(rootStorage ? rootStorage.dir : this.deps.config.memoryDir, rootStorage);\n\n    const resolveNamespaceStorage = this.deps.storageForNamespace;\n    if (resolveNamespaceStorage && this.deps.namespaceCatalog?.enabled) {\n      let records: NamespaceRecord[] = [];\n      try {\n        records = await this.deps.namespaceCatalog.listNamespaces();\n      } catch (err) {\n        log.debug(`lifecycle compaction: namespace enumeration failed (non-fatal): ${err}`);\n      }\n      for (const record of records) {\n        const namespace = record.namespace.trim();\n        if (!namespace) continue;\n        try {\n          const storage = await resolveNamespaceStorage(namespace);\n          addTarget(storage.dir, storage);\n        } catch (err) {\n          log.debug(\n            `lifecycle compaction: storage resolve failed for namespace ${namespace} (non-fatal): ${err}`,\n          );\n        }\n      }\n    }\n\n    // Filesystem fallback (codex P2): when namespaces are enabled but the\n    // catalog is disabled (namespaceCatalogEnabled=false) — or a namespace is\n    // not yet cataloged — the catalog walk above finds nothing, yet per-namespace\n    // ledgers still grow under <memoryDir>/namespaces/<token>/state/. Scan that\n    // base directly so those ledgers are still bounded. Deduped by resolved dir,\n    // so a namespace already added via the catalog is not compacted twice.\n    if (resolveNamespaceCapabilities(this.deps.config).namespaces) {\n      const namespacesBase = path.join(this.deps.config.memoryDir, \"namespaces\");\n      // Symlink/traversal containment (issue #2033 codex P2): a symlinked\n      // <memoryDir>/namespaces (or a symlinked child) must not redirect the scan\n      // — and later backup/ledger rewrites — outside memoryDir. Resolve the\n      // memory root and the scan base through realpath, reject a symlinked or\n      // escaping base, and skip any symlinked/escaping child, mirroring the\n      // memory-store walkers' hardening (utils/path-containment).\n      let memoryDirReal: string;\n      try {\n        memoryDirReal = await realpath(this.deps.config.memoryDir);\n        const baseStat = await lstat(namespacesBase);\n        if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {\n          throw new Error(\"namespaces base is a symlink or not a directory\");\n        }\n        assertPathInsideRoot(memoryDirReal, await realpath(namespacesBase), namespacesBase);\n      } catch (err) {\n        if (!isErrnoCode(err, \"ENOENT\")) {\n          log.debug(`lifecycle compaction: namespaces base rejected (non-fatal): ${err}`);\n        }\n        return targets;\n      }\n      let entries: Dirent[] = [];\n      try {\n        entries = await readdir(namespacesBase, { withFileTypes: true });\n      } catch (err) {\n        if (!isErrnoCode(err, \"ENOENT\")) {\n          log.debug(`lifecycle compaction: namespaces dir scan failed (non-fatal): ${err}`);\n        }\n      }\n      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {\n        if (!entry.isDirectory() || entry.isSymbolicLink()) continue;\n        const childPath = path.join(namespacesBase, entry.name);\n        try {\n          assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);\n        } catch (err) {\n          log.debug(`lifecycle compaction: skipping out-of-root namespace dir ${childPath}: ${err}`);\n          continue;\n        }\n        // Resolve the namespace's secure-store-aware storage so an encrypted\n        // fallback ledger compacts through the correct root key/context instead\n        // of deferring forever behind a keyless plaintext StorageManager (#2033\n        // thread PRRT_kwDORJXyws6SE5fv). The on-disk dir name is EITHER a\n        // namespace identity TOKEN (ns-<hex>) OR a legacy raw namespace dir name\n        // written before tokenization (namespaces/<name>/). Decode a token back\n        // to its canonical namespace; treat a non-token dir as a raw namespace\n        // only when it is a safe route namespace (isSafeRouteNamespace), so a\n        // garbage/traversal dir name is never handed to the resolver. Passing the\n        // raw token to the resolver would re-tokenize an already-tokenized value\n        // and (for namespaces longer than 30 bytes) exceed the router's 64-char\n        // safe-route limit, so the resolver throws and the encrypted over-cap\n        // ledger defers forever — hence decode first. Resolve the route namespace\n        // and accept the keyed storage only when it roots at THIS dir: the secure\n        // store keys one master key per memory ROOT (not per namespace), the\n        // router routes a token to namespaces/<token>/ and an existing legacy raw\n        // name to its namespaces/<name>/ root, so a correct resolve returns THIS\n        // childPath; anything else is an unexpected re-route we refuse (keeping\n        // namespace isolation and never compacting the wrong ledger). A dir that\n        // neither decodes nor is a safe raw namespace, or no resolver wired\n        // (focused tests / plaintext deployments), leaves the keyless target\n        // standing: the rebuild chokepoint still refuses to downgrade an\n        // encrypted ledger, so plaintext behavior holds.\n        const decodedNamespace = namespaceIdentityFromToken(entry.name);\n        const routeNamespace =\n          decodedNamespace !== null\n            ? decodedNamespace\n            : isSafeRouteNamespace(entry.name)\n              ? entry.name\n              : null;\n        if (resolveNamespaceStorage && routeNamespace !== null) {\n          try {\n            const storage = await resolveNamespaceStorage(routeNamespace);\n            if (path.resolve(storage.dir) === path.resolve(childPath)) {\n              addTarget(storage.dir, storage);\n              continue;\n            }\n            log.debug(\n              `lifecycle compaction: fallback resolver routed ${childPath} to ${storage.dir}; `\n              + \"using keyless target\",\n            );\n          } catch (err) {\n            log.debug(\n              `lifecycle compaction: fallback storage resolve failed for ${childPath} (non-fatal): ${err}`,\n            );\n          }\n        }\n        addTarget(childPath);\n      }\n    }\n    return targets;\n  }\n\n  /**\n   * Compact one lifecycle ledger when it is at/over `threshold`. Returns\n   * `\"skipped\"` (absent or below threshold — nothing to do), `\"compacted\"`\n   * (rewritten and verified under the read/decrypt cap), `\"failed\"`\n   * (rebuild/probe threw, or the rewritten ledger is STILL over the cap — an\n   * ineffective compaction — non-fatal, retried next pass), or `\"deferred\"`\n   * (oversized but its encrypted ledger cannot be rewritten because no unlocked\n   * secure store is available — real work still pending, so the caller must NOT\n   * arm the throttle). #2033: a deferred/failed target is distinct from a genuine\n   * no-op so one namespace compacting cannot suppress retries for another, and\n   * an over-cap rewrite never arms the throttle.\n   */\n  private async compactLifecycleLedgerTarget(\n    target: { memoryDir: string; storage?: StorageManager },\n    threshold: number,\n  ): Promise<\"skipped\" | \"compacted\" | \"failed\" | \"deferred\"> {\n    const ledgerPath = path.join(target.memoryDir, \"state\", \"memory-lifecycle-ledger.jsonl\");\n    let size = 0;\n    try {\n      size = (await stat(ledgerPath)).size;\n    } catch (err) {\n      if (isErrnoCode(err, \"ENOENT\")) return \"skipped\"; // absent — nothing to compact yet.\n      log.warn(\n        `lifecycle ledger size check failed (non-fatal) for ${target.memoryDir}: ${err}`,\n      );\n      return \"failed\";\n    }\n    // #2033 finding (1): an encrypted ledger becomes unreadable once its on-disk\n    // size reaches the whole-file decrypt cap (the reader refuses at/over it), so\n    // the effective compaction trigger for an encrypted target is clamped to that\n    // cap even when the configured threshold is LARGER — otherwise a ledger that\n    // grows past the cap but stays below a bigger threshold would never compact\n    // and stay permanently unreadable. Plaintext streaming is unaffected at any\n    // size, so a plaintext target keeps the configured threshold. The cheap\n    // pre-check skips anything below the smaller of the two before paying for the\n    // extra lstat/open the encryption probe costs.\n    if (size < Math.min(threshold, this.lifecycleLedgerMaxBytes)) return \"skipped\";\n    let encrypted: boolean;\n    try {\n      encrypted = await probeEncryptedRegularFileHeader(ledgerPath);\n    } catch (err) {\n      log.warn(`lifecycle ledger encryption probe failed (non-fatal) for ${ledgerPath}: ${err}`);\n      return \"failed\";\n    }\n    const effectiveThreshold = encrypted\n      ? Math.min(threshold, this.lifecycleLedgerMaxBytes)\n      : threshold;\n    if (size < effectiveThreshold) return \"skipped\";\n    // No plaintext rewrite of an encrypted-at-rest ledger (#2033): rebuilding an\n    // encrypted ledger without an unlocked secure StorageManager would either\n    // fail the preserve-read (locked store) or downgrade the ledger to plaintext.\n    // Report \"deferred\" (NOT \"skipped\"): the ledger is over threshold and still\n    // needs compaction, so the throttle must stay un-armed and retry once a key\n    // is available — a \"skipped\" here would let another target's success arm the\n    // throttle and suppress this pending work for the whole interval (#2033).\n    if (encrypted && !(target.storage?.isSecureStoreUnlocked() ?? false)) {\n      log.warn(\n        `lifecycle ledger at ${ledgerPath} is encrypted at rest but no unlocked secure `\n        + `storage is available; deferring auto-compaction to avoid a plaintext rewrite. `\n        + `Run 'remnic rebuild-memory-lifecycle-ledger --write' after unlocking.`,\n      );\n      return \"deferred\";\n    }\n    // #2033 findings (2)+(4): the rewrite budget bounds the PLAINTEXT payload, but\n    // an encrypted-at-rest target adds a fixed secure-store envelope on disk.\n    // Reserve that envelope (plus one byte) from the plaintext budget so the\n    // encrypted file lands STRICTLY below the reader's refusal cap and the\n    // post-write check — which stats the on-disk (encrypted) size against the cap\n    // — cannot fail forever on a plaintext budget that equals the cap (the\n    // endless-retry bug). Base this on whether the REPLACEMENT will be encrypted\n    // (the storage write mode), NOT only on the current file header: a\n    // plaintext ledger rewritten under `secureStoreEncryptOnWrite` with the key\n    // set becomes encrypted, so it needs the reserve even though its current\n    // header is plaintext (#2033 write-mode finding).\n    const replacementEncrypted =\n      encrypted || (target.storage?.willEncryptStateWrites() ?? false);\n    const plaintextBudget = replacementEncrypted\n      ? this.lifecycleLedgerMaxBytes - SECURE_STORE_ENVELOPE_OVERHEAD_BYTES - 1\n      : this.lifecycleLedgerMaxBytes - 1;\n    try {\n      const result = await rebuildMemoryLifecycleLedger({\n        memoryDir: target.memoryDir,\n        dryRun: false,\n        storage: target.storage,\n        // Background compaction must not lose append-only history that\n        // frontmatter cannot reconstruct (issue #1910); the manual CLI repair\n        // rebuild now preserves and bounds identically (#2033).\n        preserveExistingEvents: true,\n        // Bound the PLAINTEXT rewrite to a budget that reserves the secure-store\n        // envelope, so the on-disk ledger (plaintext, or plaintext+envelope when\n        // encrypted) is strictly below the read/decrypt cap; overflow lands in\n        // the verbatim backup (#2033 findings 2+4).\n        maxLedgerBytes: plaintextBudget,\n      });\n      // Verify the rewritten ledger is actually bounded. A compaction that left\n      // the ledger at/over the read/decrypt cap is ineffective (the ledger would\n      // be unreadable) — report \"failed\" so the throttle stays un-armed and the\n      // next pass retries rather than declaring success (#2033).\n      let rewrittenSize = 0;\n      try {\n        rewrittenSize = (await stat(ledgerPath)).size;\n      } catch (err) {\n        log.warn(`lifecycle ledger post-compaction size check failed (non-fatal) for ${target.memoryDir}: ${err}`);\n        return \"failed\";\n      }\n      if (rewrittenSize >= this.lifecycleLedgerMaxBytes) {\n        log.warn(\n          `lifecycle ledger auto-compaction ineffective for ${target.memoryDir}: rewritten `\n          + `ledger is ${rewrittenSize}B, still at/over the ${this.lifecycleLedgerMaxBytes}-byte `\n          + `read/decrypt cap; leaving the throttle un-armed to retry.`,\n        );\n        return \"failed\";\n      }\n      if (result.rewritten === false) {\n        // No-op pass (#2033 thread PRRT_kwDORJXyws6SExst): a preserving rebuild\n        // would reproduce the current ledger byte-for-byte, so it skipped the\n        // backup+rewrite. The ledger stays over the trigger but under the cap;\n        // report \"compacted\" so the throttle still arms (nothing more can be\n        // done until the ledger grows), which stops the periodic re-archive/\n        // rewrite churn the review flagged — the archive no longer grows.\n        log.debug(\n          `lifecycle ledger already compact for ${target.memoryDir}: ${rewrittenSize}B, `\n          + `no rewrite needed (throttle armed to avoid re-archiving an unchanged ledger).`,\n        );\n      } else {\n        log.info(\n          `lifecycle ledger auto-compacted (${target.memoryDir}): ${size}B -> `\n          + `${rewrittenSize}B, ${result.rebuiltRows} rows `\n          + `(${result.preservedAppendOnlyRows ?? 0} append-only preserved, `\n          + `${result.archivedOverflowRows ?? 0} overflow archived), `\n          + `backup=${result.backupPath ?? \"none\"}`,\n        );\n      }\n      return \"compacted\";\n    } catch (err) {\n      log.warn(\n        `lifecycle ledger auto-compaction failed (non-fatal) for ${target.memoryDir}: ${err}`,\n      );\n      return \"failed\";\n    }\n  }\n\n  /** Build the namespace-aware maintenance plan for one job. */\n  private async namespaceMaintenancePlan(\n    jobName: string,\n  ): Promise<NamespaceMaintenancePlan> {\n    return planNamespaceMaintenance(this.deps.config, {\n      jobName,\n      catalog: this.deps.namespaceCatalog,\n    });\n  }\n\n  // ───────────────────────────────────────────────────────────────────────\n  // Lifecycle\n  // ───────────────────────────────────────────────────────────────────────\n\n  /**\n   * Clear any pending debounce timer. Called from the orchestrator's\n   * destroy() so a late tick does not fire on a torn-down instance.\n   */\n  dispose(): void {\n    if (this.qmdMaintenanceTimer) {\n      clearTimeout(this.qmdMaintenanceTimer);\n      this.qmdMaintenanceTimer = null;\n    }\n    this.qmdMaintenancePending = false;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-WMWVO45V.js → chunk-MC6XO7T4.js}

@@ -1,6 +1,6 @@
 import {
   writeFileAtomically
-} from "./chunk-SFQ6QNL7.js";
+} from "./chunk-R6YJI3HE.js";
 
 // src/maintenance/archive-observations.ts
 import path from "path";
@@ -131,4 +131,4 @@ async function archiveObservations(options) {
 export {
   archiveObservations
 };
-//# sourceMappingURL=chunk-WMWVO45V.js.map
+//# sourceMappingURL=chunk-MC6XO7T4.js.map