@inetafrica/open-claudia 2.6.40 → 2.6.41

package/core/dream.js

@@ -41,6 +41,16 @@ const DREAM_MODEL = pickDreamModel();
 // reasoning effort by default. Overridable via DREAM_EFFORT (low|medium|high|xhigh|max).
 const DREAM_EFFORT = process.env.DREAM_EFFORT || "max";
 const DREAM_CRON = process.env.DREAM_CRON || "0 4 * * *";
+// Consolidation model timeout. The model weighs the WHOLE corpus in one pass,
+// so a fixed budget that was fine at 30 packs starves at 130 (the timeout that
+// motivated this). Floor 20m, +6s per pack, capped at 40m; DREAM_TIMEOUT_MS
+// (ms) overrides entirely. Even if it still times out, the deterministic phases
+// (prefix nesting, graph tend) run regardless — the model pass is best-effort.
+function dreamTimeoutMs(packCount = 0) {
+  const override = Number(process.env.DREAM_TIMEOUT_MS);
+  if (override > 0) return override;
+  return Math.min(20 * 60 * 1000 + packCount * 6000, 40 * 60 * 1000);
+}
 const MAX_PACK_CHARS = 2500;
 const MAX_ENTITY_CHARS = 900;
 const LIMITS = {
@@ -277,7 +287,7 @@ function applyDream(decision, backupRoot) {
   const lines = [];
   const gone = new Set(); // dirs/slugs removed this run
 
-  for (const m of decision.merges) {
+  for (const m of decision.merges || []) {
     try {
       const into = m?.into && packs.readPack(m.into);
       const from = [].concat(m?.from || []).filter((d) => d && d !== m.into && !gone.has(d) && packs.readPack(d));
@@ -312,7 +322,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] merge failed: ${e.message}`); }
   }
 
-  for (const u of decision.umbrellas) {
+  for (const u of decision.umbrellas || []) {
     try {
       const dir = packs.slugify(u?.dir || u?.name);
       if (!dir || gone.has(dir)) continue;
@@ -345,7 +355,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] umbrella failed: ${e.message}`); }
   }
 
-  for (const p of decision.parents) {
+  for (const p of decision.parents || []) {
     try {
       const child = p?.pack && !gone.has(p.pack) && packs.readPack(p.pack);
       if (!child || !p.parent || gone.has(p.parent) || !packs.readPack(p.parent)) continue;
@@ -358,7 +368,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] parent failed: ${e.message}`); }
   }
 
-  for (const r of decision.retag) {
+  for (const r of decision.retag || []) {
     try {
       if (!r?.pack || gone.has(r.pack) || !packs.readPack(r.pack)) continue;
       const desc = typeof r.description === "string" ? r.description.trim() : "";
@@ -374,7 +384,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] retag failed: ${e.message}`); }
   }
 
-  for (const em of decision.entity_merges) {
+  for (const em of decision.entity_merges || []) {
     try {
       const into = em?.into && entities.readEntity(em.into);
       const from = [].concat(em?.from || []).filter((s) => s && s !== em.into && !gone.has(s) && entities.readEntity(s));
@@ -397,7 +407,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] entity merge failed: ${e.message}`); }
   }
 
-  for (const en of decision.entity_notes) {
+  for (const en of decision.entity_notes || []) {
     try {
       const ent = en?.entity && !gone.has(en.entity) && entities.readEntity(en.entity);
       if (!ent || typeof en.notes !== "string" || !en.notes.trim()) continue;
@@ -736,14 +746,26 @@ async function runDream({ trigger = "manual" } = {}) {
 
   _dreaming = true;
   try {
-    const { text } = await spawnSubagent(buildDreamPrompt(), {
-      model: DREAM_MODEL,
-      effort: DREAM_EFFORT,
-      timeoutMs: 8 * 60 * 1000,
-      systemPrompt: "You are a background memory consolidation process. Reply with ONLY the requested JSON object. No prose, no markdown, no tool use.",
-    });
-    const decision = parseDream(text);
-    if (!decision) return { skipped: "dream model returned unparseable output" };
+    // Best-effort consolidation: on a large corpus this call can time out or
+    // return unreadable JSON. That must NOT abort the dream — the deterministic
+    // phases below (prefix nesting, graph tend) need no model and are the
+    // load-bearing cleanup. Catch any model failure, fall back to an empty
+    // decision (applyDream no-ops), note it for the report, and carry on.
+    let decision = null;
+    let modelFailNote = "";
+    try {
+      const { text } = await spawnSubagent(buildDreamPrompt(), {
+        model: DREAM_MODEL,
+        effort: DREAM_EFFORT,
+        timeoutMs: dreamTimeoutMs(packCount),
+        systemPrompt: "You are a background memory consolidation process. Reply with ONLY the requested JSON object. No prose, no markdown, no tool use.",
+      });
+      decision = parseDream(text);
+      if (!decision) modelFailNote = "the AI consolidation step returned unreadable output";
+    } catch (e) {
+      modelFailNote = `the AI consolidation step didn't finish (${e.message})`;
+    }
+    if (!decision) decision = { report: "" };
 
     const backupRoot = makeBackupRoot();
     const applied = applyDream(decision, backupRoot);
@@ -754,7 +776,10 @@ async function runDream({ trigger = "manual" } = {}) {
     try { nestLines = nestPrefixFamilies(backupRoot).lines; }
     catch (e) { console.warn(`[dream] nesting pass failed: ${e.message}`); }
     const consolidationLines = applied.concat(nestLines);
-    const report = decision.report || (consolidationLines.length > 0 ? "Tidied up my memory overnight." : "");
+    let report = decision.report || (consolidationLines.length > 0 ? "Tidied up my memory overnight." : "");
+    if (modelFailNote) {
+      report = `Heads up — ${modelFailNote}, so I skipped the AI-led merges this round but still ran the automatic filing + graph upkeep.${report ? " " + report : ""}`;
+    }
 
     // Phase 2: self-improvement introspection. Reviews the day's seeds, reads
     // its own code/memory READ-ONLY (allowedTools whitelist), promotes lessons
@@ -860,7 +885,7 @@ function initDream(adapters) {
 }
 
 module.exports = {
-  runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers, nestPrefixFamilies,
+  runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers, nestPrefixFamilies, dreamTimeoutMs,
   buildIntrospectionPrompt, parseIntrospection, applyIntrospection, writeDreamReport,
   enabled, summaryEnabled, introspectEnabled, selfApplyEnabled,
   DREAM_CRON, DREAM_MODEL, DREAM_EFFORT, PROMOTE_MIN_PROJECTS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.40",
+  "version": "2.6.41",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {

package/test-pack-nesting.js

@@ -77,6 +77,21 @@ assert.ok(res.lines.some((l) => l.includes("billing")), "nest pass announces the
 const again = dream.nestPrefixFamilies(null);
 assert.strictEqual(again.filed, 0, "second pass files nothing new");
 
+// ── dream resilience: the deterministic cleanup must not depend on the model ──
+// applyDream tolerates an empty decision (the fallback used when the AI
+// consolidation step times out / returns garbage) instead of throwing.
+assert.deepStrictEqual(dream.applyDream({}, null), [], "empty decision applies nothing, throws nothing");
+assert.deepStrictEqual(dream.applyDream({ report: "" }, null), [], "report-only fallback decision is safe");
+
+// timeout scales with corpus: floor 20m, grows per pack, capped at 40m, env override.
+assert.strictEqual(dream.dreamTimeoutMs(0), 20 * 60 * 1000, "floor is 20 minutes");
+assert.ok(dream.dreamTimeoutMs(130) > dream.dreamTimeoutMs(30), "more packs → longer budget");
+assert.strictEqual(dream.dreamTimeoutMs(100000), 40 * 60 * 1000, "capped at 40 minutes");
+const prev = process.env.DREAM_TIMEOUT_MS;
+process.env.DREAM_TIMEOUT_MS = "777000";
+assert.strictEqual(dream.dreamTimeoutMs(50), 777000, "DREAM_TIMEOUT_MS overrides entirely");
+if (prev === undefined) delete process.env.DREAM_TIMEOUT_MS; else process.env.DREAM_TIMEOUT_MS = prev;
+
 // ── versioned-only fold (FTS-gated): a versioned proposal folds into its pack,
 //    a non-versioned near-duplicate does NOT. Skipped when node:sqlite is absent. ──
 if (packs.reindex()) {