@remnic/core 10.0.12 → 10.0.14

package/dist/{chunk-J7MDPTX7.js → chunk-EUAIYYYR.js}

@@ -1,9 +1,9 @@
 import {
   PROJECTION_REBUILD_RUNNER_FLAG
-} from "./chunk-KJOGIRMF.js";
+} from "./chunk-CB6ANA2I.js";
 import {
   startLocationAutoSync
-} from "./chunk-SSAXGPXY.js";
+} from "./chunk-OP6N4H6A.js";
 import {
   ensureContradictionScanCron,
   ensureDaySummaryCron,
@@ -13,16 +13,22 @@ import {
   ensureProceduralMiningCron,
   graphEdgeDecayCadenceToCronExpr
 } from "./chunk-666A3MOW.js";
+import {
+  CompoundingEngine,
+  isIsoWeekId,
+  msUntilNextIsoWeek,
+  previousIsoWeekId
+} from "./chunk-UQDG3YLN.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-EKKAHJ4B.js";
+} from "./chunk-YE36AJL7.js";
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-O52WWLKU.js";
+} from "./chunk-JIHMUOOS.js";
 import {
   rebuildMemoryProjection
-} from "./chunk-56GJLXBA.js";
+} from "./chunk-Y4NKEXQT.js";
 import {
   DEFAULT_TIMELINE_CATEGORIES,
   TIMELINE_RESERVED_IDLE,
@@ -39,7 +45,7 @@ import {
 } from "./chunk-EWMRFW3F.js";
 import {
   LocalLlmClient
-} from "./chunk-JXSYWTFK.js";
+} from "./chunk-DYJHGJZ4.js";
 import {
   FallbackLlmClient
 } from "./chunk-TKC5LZ43.js";
@@ -61,7 +67,7 @@ import {
   drainPendingLifecycleLedgerIfAny,
   pendingLifecycleLedgerDir,
   readProjectionRebuiltAt
-} from "./chunk-FQD2KPQH.js";
+} from "./chunk-P55FACBG.js";
 import {
   displayErrorDetail,
   openBetterSqlite3
@@ -70,6 +76,9 @@ import {
   assertPathInsideRoot,
   listContainedSpillFiles
 } from "./chunk-C7HJ3NEI.js";
+import {
+  writeFileAtomically
+} from "./chunk-BTNNL7ZW.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-PCXDUHQH.js";
@@ -82,7 +91,7 @@ import {
   resolveNamespaceCapabilities,
   resolveQmdCapabilities,
   resolveRecallAuxiliaryCapabilities
-} from "./chunk-2EMROIXS.js";
+} from "./chunk-C5LWPYS3.js";
 import {
   resolveHomeDir
 } from "./chunk-P2QRMMVQ.js";
@@ -99,8 +108,8 @@ import {
 
 // src/orchestration/maintenance.ts
 import { existsSync as existsSync2 } from "fs";
-import { appendFile, lstat, mkdir as mkdir3, readFile as readFile2, readdir, realpath, stat, writeFile as writeFile2 } from "fs/promises";
-import path6 from "path";
+import { appendFile, lstat as lstat2, mkdir as mkdir3, readFile as readFile2, readdir, realpath, stat, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
 
 // src/maintenance/day-summary-cron.ts
 function resolveDaySummaryCronModel(config) {
@@ -364,6 +373,134 @@ async function maybeRebuildMemoryProjectionScheduled(opts) {
   }
 }
 
+// src/compounding/weekly-scheduler.ts
+import { lstat } from "fs/promises";
+import path2 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`);
+}
+async function defaultWeekDone(memoryDir, weekId) {
+  try {
+    await lstat(compoundingWeeklyDoneMarkerPath(memoryDir, weekId));
+    return true;
+  } catch (error) {
+    if (isNotFound(error)) return false;
+    throw error;
+  }
+}
+async function defaultMarkWeekDone(memoryDir, weekId) {
+  await writeFileAtomically(compoundingWeeklyDoneMarkerPath(memoryDir, weekId), `${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function startCompoundingWeeklyScheduler(options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const logger = options.log ?? log;
+  const weekDone = options.weekDone ?? ((weekId) => defaultWeekDone(options.memoryDir, weekId));
+  const markWeekDone = options.markWeekDone ?? ((weekId) => defaultMarkWeekDone(options.memoryDir, weekId));
+  const setTimer = options.setTimer ?? ((fn, ms) => {
+    const timer2 = setTimeout(fn, ms);
+    timer2.unref?.();
+    return timer2;
+  });
+  const clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+  let stopped = false;
+  let pending = false;
+  let inFlight = null;
+  let timer = null;
+  let retryWeekId = null;
+  const runWeek = async (weekId) => {
+    try {
+      if (await weekDone(weekId)) {
+        if (retryWeekId === weekId) retryWeekId = null;
+        logger.debug(`compounding weekly cron: ${weekId} already synthesized by the scheduler, skipping`);
+        return { status: "skipped", weekId };
+      }
+      await options.synthesizeWeekly(weekId);
+      await markWeekDone(weekId);
+      logger.info(`compounding weekly cron: synthesized ${weekId}`);
+      return { status: "synthesized", weekId };
+    } catch (error) {
+      retryWeekId = weekId;
+      const name = error instanceof Error ? error.name : "Error";
+      logger.warn(`compounding weekly cron: ${weekId} failed (${name}) \u2014 retrying on the next tick`);
+      return { status: "failed", weekId };
+    }
+  };
+  const arm = () => {
+    if (stopped) return;
+    if (timer) clearTimer(timer);
+    const delay = msUntilNextIsoWeek(now());
+    timer = setTimer(() => {
+      timer = null;
+      if (stopped) return;
+      arm();
+      void request();
+    }, delay);
+    timer.unref?.();
+  };
+  const doTick = async () => {
+    const due = previousIsoWeekId(now());
+    const weekId = retryWeekId ?? due;
+    const first = await runWeek(weekId);
+    if (first.status === "failed" || weekId === due) return first;
+    return runWeek(due);
+  };
+  const request = () => {
+    if (stopped) return Promise.resolve({ status: "stopped", weekId: null });
+    if (inFlight) {
+      pending = true;
+      return inFlight.then(() => ({ status: "coalesced", weekId: null }));
+    }
+    const run = doTick().finally(() => {
+      inFlight = null;
+      if (!stopped && pending) {
+        pending = false;
+        void request();
+      }
+    });
+    inFlight = run;
+    return run;
+  };
+  arm();
+  void request();
+  return {
+    tick: () => request(),
+    async whenIdle() {
+      while (inFlight) await inFlight;
+    },
+    async stop() {
+      stopped = true;
+      pending = false;
+      if (timer) clearTimer(timer);
+      timer = null;
+      while (inFlight) await inFlight;
+    }
+  };
+}
+function createCompoundingWeeklyCron(deps) {
+  const caps = resolveConsolidationCapabilities(deps.config);
+  if (!caps.compounding || !caps.compoundingWeeklyCron) return null;
+  try {
+    const engine = new CompoundingEngine(deps.config, deps.getStorage?.());
+    const handle = startCompoundingWeeklyScheduler({
+      memoryDir: deps.config.memoryDir,
+      synthesizeWeekly: (weekId) => engine.synthesizeWeekly({ weekId })
+    });
+    log.info("compounding weekly cron armed");
+    return handle;
+  } catch (error) {
+    const name = error instanceof Error ? error.name : "Error";
+    log.warn(`compounding weekly cron failed to arm (${name}) \u2014 non-fatal`);
+    return null;
+  }
+}
+
 // src/activity/reindex.ts
 async function refreshActivityIndex(qmd, collection, signal) {
   const execution = signal === void 0 ? void 0 : { signal };
@@ -381,17 +518,17 @@ async function refreshActivityIndex(qmd, collection, signal) {
 // src/activity/store.ts
 import { mkdirSync } from "fs";
 import { mkdir } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 var ACTIVITY_SCHEMA_VERSION = 1;
 var MAX_SEARCH_RESULTS = 100;
 function activityDatabasePath(memoryDir) {
-  return path2.join(memoryDir, "state", "activity.sqlite");
+  return path3.join(memoryDir, "state", "activity.sqlite");
 }
 async function ensureActivityStateDir(memoryDir) {
-  await mkdir(path2.join(memoryDir, "state"), { recursive: true });
+  await mkdir(path3.join(memoryDir, "state"), { recursive: true });
 }
 function openActivityDatabase(memoryDir) {
-  mkdirSync(path2.join(memoryDir, "state"), { recursive: true });
+  mkdirSync(path3.join(memoryDir, "state"), { recursive: true });
   const db = openBetterSqlite3(activityDatabasePath(memoryDir));
   db.pragma("journal_mode = WAL");
   db.pragma("busy_timeout = 5000");
@@ -640,7 +777,7 @@ var ActivityStore = class _ActivityStore {
 // src/activity/pipeline.ts
 import { mkdir as mkdir2, readFile, rename, writeFile } from "fs/promises";
 import { randomUUID } from "crypto";
-import path3 from "path";
+import path4 from "path";
 var MAX_SYNC_PAGES = 1e4;
 function activityCursorKey(machine, date) {
   return `${machine}\0${date}`;
@@ -679,7 +816,7 @@ async function writeDigestIfChanged(memoryDir, date, serialized) {
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
   }
-  await mkdir2(path3.dirname(target), { recursive: true, mode: 448 });
+  await mkdir2(path4.dirname(target), { recursive: true, mode: 448 });
   const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
   await writeFile(temporary, serialized, { encoding: "utf8", mode: 384 });
   await rename(temporary, target);
@@ -826,8 +963,8 @@ function responsePage(value, machine) {
     nextCursor
   };
 }
-function requestUrl(baseUrl, path7, query) {
-  const url = new URL(path7, baseUrl);
+function requestUrl(baseUrl, path8, query) {
+  const url = new URL(path8, 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();
@@ -882,13 +1019,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 path5 from "path";
+import path6 from "path";
 
 // src/activity/timeline/corrections.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import path4 from "path";
+import path5 from "path";
 function timelineCorrectionDatabasePath(memoryDir) {
-  return path4.join(memoryDir, "state", "activity-timeline.sqlite");
+  return path5.join(memoryDir, "state", "activity-timeline.sqlite");
 }
 function rowToCorrection(row) {
   return {
@@ -904,7 +1041,7 @@ var TimelineCorrectionStore = class _TimelineCorrectionStore {
     this.db = db;
   }
   static open(memoryDir) {
-    mkdirSync2(path4.join(memoryDir, "state"), { recursive: true });
+    mkdirSync2(path5.join(memoryDir, "state"), { recursive: true });
     const db = openBetterSqlite3(timelineCorrectionDatabasePath(memoryDir));
     db.pragma("journal_mode = WAL");
     db.pragma("busy_timeout = 5000");
@@ -1288,7 +1425,7 @@ async function runTimelineCardAnalysis(input) {
 
 // src/activity/timeline/regenerate.ts
 var TIMELINE_DAY_FORMAT_VERSION = 1;
-var TIMELINE_DAY_DIR = path5.join("activity", "timeline");
+var TIMELINE_DAY_DIR = path6.join("activity", "timeline");
 var inflight = /* @__PURE__ */ new Map();
 function requireToken(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
@@ -1301,7 +1438,7 @@ function timelineDayPath(memoryDir, date) {
   if (!isValidActivityDate(date)) {
     throw new RangeError("date must be a real YYYY-MM-DD day");
   }
-  return path5.join(path5.resolve(root), TIMELINE_DAY_DIR, `${date}.json`);
+  return path6.join(path6.resolve(root), TIMELINE_DAY_DIR, `${date}.json`);
 }
 function snapshotToObservation(snapshot) {
   if (typeof snapshot.id !== "number") return null;
@@ -1331,7 +1468,7 @@ function localDatesForUtcRange(fromMs, toMs, timezone) {
 function listPersistedTimelineDates(memoryDir) {
   let entries;
   try {
-    entries = readdirSync(path5.join(path5.resolve(requireToken(memoryDir, "memoryDir")), TIMELINE_DAY_DIR));
+    entries = readdirSync(path6.join(path6.resolve(requireToken(memoryDir, "memoryDir")), TIMELINE_DAY_DIR));
   } catch {
     return [];
   }
@@ -1425,7 +1562,7 @@ function persistDay(filePath, payload) {
       throw error;
     }
   }
-  mkdirSync3(path5.dirname(filePath), { recursive: true, mode: 448 });
+  mkdirSync3(path6.dirname(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
   writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
   try {
@@ -1520,7 +1657,7 @@ async function regenerateUncached(input) {
   }
 }
 async function regenerateTimelineDay(input) {
-  const key = `${path5.resolve(requireToken(input.memoryDir, "memoryDir"))}\0${input.date}`;
+  const key = `${path6.resolve(requireToken(input.memoryDir, "memoryDir"))}\0${input.date}`;
   const pending = inflight.get(key);
   if (pending !== void 0) return pending;
   const run = regenerateUncached(input).finally(() => {
@@ -1847,6 +1984,7 @@ var MaintenanceScheduler = class {
   // ── Location day-sync scheduler (issue #2047) — master default-off; the
   // timer + lifecycle contract lives in location/scheduler.ts.
   locationAutoSync = null;
+  compoundingWeekly = null;
   // ───────────────────────────────────────────────────────────────────────
   // Cron auto-registration
   // ───────────────────────────────────────────────────────────────────────
@@ -1910,9 +2048,14 @@ var MaintenanceScheduler = class {
       });
     }
   }
+  armCompoundingWeeklyCron() {
+    if (this.disposed) return false;
+    this.compoundingWeekly ??= createCompoundingWeeklyCron(this.deps);
+    return this.compoundingWeekly !== null;
+  }
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("day-summary cron: jobs.json not found, skipping auto-register");
@@ -1942,7 +2085,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -1964,7 +2107,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -1984,7 +2127,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -2004,7 +2147,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
@@ -2024,7 +2167,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
@@ -2296,7 +2439,7 @@ var MaintenanceScheduler = class {
    */
   async hasOverCapEncryptedLifecycleLedger(targets) {
     for (const target of targets) {
-      const ledgerPath = path6.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+      const ledgerPath = path7.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
       let size;
       try {
         size = (await stat(ledgerPath)).size;
@@ -2348,7 +2491,7 @@ var MaintenanceScheduler = class {
    * containment guard on every spill file it reads or deletes.
    */
   async drainPendingLifecycleAppendsForPath(memoryDir) {
-    const ledgerPath = path6.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path7.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     const spillDir = pendingLifecycleLedgerDir(ledgerPath);
     let spillFiles;
     let claimedOrphans;
@@ -2362,7 +2505,7 @@ var MaintenanceScheduler = class {
     if (spillFiles.length === 0 && claimedOrphans.length === 0) return;
     const io = {
       writeSecure: async (filePath, payload) => {
-        await mkdir3(path6.dirname(filePath), { recursive: true });
+        await mkdir3(path7.dirname(filePath), { recursive: true });
         await writeFile2(filePath, payload, "utf-8");
       },
       readSecure: async (filePath) => {
@@ -2383,7 +2526,7 @@ var MaintenanceScheduler = class {
           await appendFile(ledgerPath, payload, "utf-8");
         },
         async () => {
-          await mkdir3(path6.dirname(ledgerPath), { recursive: true });
+          await mkdir3(path7.dirname(ledgerPath), { recursive: true });
         }
       );
     } catch (err) {
@@ -2401,7 +2544,7 @@ var MaintenanceScheduler = class {
     const targets = [];
     const seen = /* @__PURE__ */ new Set();
     const addTarget = (memoryDir, storage) => {
-      const key = path6.resolve(memoryDir);
+      const key = path7.resolve(memoryDir);
       if (seen.has(key)) return;
       seen.add(key);
       targets.push({ memoryDir, storage });
@@ -2430,11 +2573,11 @@ var MaintenanceScheduler = class {
       }
     }
     if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      const namespacesBase = path6.join(this.deps.config.memoryDir, "namespaces");
+      const namespacesBase = path7.join(this.deps.config.memoryDir, "namespaces");
       let memoryDirReal;
       try {
         memoryDirReal = await realpath(this.deps.config.memoryDir);
-        const baseStat = await lstat(namespacesBase);
+        const baseStat = await lstat2(namespacesBase);
         if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
           throw new Error("namespaces base is a symlink or not a directory");
         }
@@ -2455,7 +2598,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 = path6.join(namespacesBase, entry.name);
+        const childPath = path7.join(namespacesBase, entry.name);
         try {
           assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);
         } catch (err) {
@@ -2467,7 +2610,7 @@ var MaintenanceScheduler = class {
         if (resolveNamespaceStorage && routeNamespace !== null) {
           try {
             const storage = await resolveNamespaceStorage(routeNamespace);
-            if (path6.resolve(storage.dir) === path6.resolve(childPath)) {
+            if (path7.resolve(storage.dir) === path7.resolve(childPath)) {
               addTarget(storage.dir, storage);
               continue;
             }
@@ -2498,7 +2641,7 @@ var MaintenanceScheduler = class {
    * an over-cap rewrite never arms the throttle.
    */
   async compactLifecycleLedgerTarget(target, threshold) {
-    const ledgerPath = path6.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path7.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     let size = 0;
     try {
       size = (await stat(ledgerPath)).size;
@@ -2595,6 +2738,8 @@ var MaintenanceScheduler = class {
     const activityDrain = this.activityRegistrar.dispose();
     const locationDrain = this.locationAutoSync?.stop() ?? Promise.resolve();
     this.locationAutoSync = null;
+    const weeklyDrain = this.compoundingWeekly?.stop() ?? Promise.resolve();
+    this.compoundingWeekly = null;
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;
@@ -2602,6 +2747,7 @@ var MaintenanceScheduler = class {
     this.qmdMaintenancePending = false;
     await activityDrain;
     await locationDrain;
+    await weeklyDrain;
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;
@@ -2647,4 +2793,4 @@ export {
   ActivitySyncScheduler,
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-J7MDPTX7.js.map
+//# sourceMappingURL=chunk-EUAIYYYR.js.map