@inetafrica/open-claudia 2.6.40 → 2.6.42

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v2.6.42
+- **Read-time `📖 Recalled my notes on …` now fires for direct file reads, not just the CLI.** The read-side recall banner — and the Hebbian co-use signal that reinforces the recall graph — was wired only to shell commands, watching for `open-claudia pack show <dir>` / `entity show <slug>`. When the agent opened one of its own notes by reading the raw `…/packs/<dir>/PACK.md` or `…/entities/<slug>.md` straight through the Read tool, the detector never saw it: no banner, and the open never counted as co-use. A new `core/recall/read-signal.js` resolves a file path to its memory node (mirroring the existing Write/Edit path-detection), and `runner.js` calls it on Read tool-uses across the Claude and Cursor backends — deduped against the CLI path via the shared notify key, so reading the same node both ways still announces once. Adds `test-read-signal.js`.
+
 ## v2.6.37
 - **`/recall [on|off]` — watch recall work.** A per-chat debug toggle that, when on, posts a short `🧠 Recall this turn` line just before each reply listing the packs/entities that surfaced — and on the **discoverer** engine, the one-line why-bullet for each. On a gated turn (pre-gate skipped recall) it says so; on a quiet turn with no matches it stays silent. The engines now return a `why` map + `gated` flag, `promptWithDynamicContext` captures a recall summary into the per-turn `consumeLastInjected()` buffer, and `runner.js` renders it when `settings.showRecall` is set. Off by default; flip with `/recall` (buttons) or `/recall on`.
 

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/core/recall/read-signal.js

@@ -0,0 +1,32 @@
+// Read-time recall signal: resolve a file path to the memory node it
+// represents — a context pack (…/packs/<dir>/PACK.md) or an entity note
+// (…/entities/<slug>.md) — or null if it's neither.
+//
+// The runner fires "📖 Recalled my notes on …" and reinforces the recall
+// co-use graph when the agent OPENS one of its own notes. That detection used
+// to watch only shell commands (`open-claudia pack show <dir>` / `entity show
+// <slug>`), so reading the raw .md straight through the Read tool was invisible
+// to both the banner and the graph. This mirrors the Write/Edit path-detection
+// so a direct read counts the same as a CLI read. Best-effort: it returns a
+// display name when the doc is on disk and falls back to the id otherwise.
+const packsLib = require("../packs");
+const entitiesLib = require("../entities");
+
+function recallNodeFromPath(filePath) {
+  if (!filePath) return null;
+  try {
+    const packDir = packsLib.packNameFromPath(filePath);
+    if (packDir) {
+      const pack = packsLib.readPack(packDir);
+      return { kind: "pack", id: packDir, name: (pack && (pack.name || pack.dir)) || packDir };
+    }
+    const entSlug = entitiesLib.entityNameFromPath(filePath);
+    if (entSlug) {
+      const ent = entitiesLib.readEntity(entSlug);
+      return { kind: "entity", id: entSlug, name: (ent && (ent.name || ent.slug)) || entSlug };
+    }
+  } catch (e) { /* best-effort: announcements never block a turn */ }
+  return null;
+}
+
+module.exports = { recallNodeFromPath };

package/core/runner.js

@@ -28,6 +28,7 @@ const skillsLib = require("./skills");
 const packsLib = require("./packs");
 const entitiesLib = require("./entities");
 const packReview = require("./pack-review");
+const { recallNodeFromPath } = require("./recall/read-signal");
 const {
   appendUsageRecord,
   loadUsageHistory,
@@ -897,6 +898,20 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     } catch (e) { /* announcements are best-effort */ }
   };
 
+  // The same 📖 signal when the agent opens a note with the Read tool instead
+  // of the CLI: noteRecallFromShell only sees shell commands, so a raw-file
+  // read of a pack/entity would otherwise be invisible to both the banner and
+  // the co-use graph. Deduped against the CLI path via the shared notifySkill
+  // key, so reading the same node both ways still announces only once.
+  const noteRecallFromReadPath = (filePath) => {
+    try {
+      const node = recallNodeFromPath(filePath);
+      if (!node) return;
+      openedThisTurn.add(`${node.kind}:${node.id}`);
+      notifySkill(`recall:${node.kind}:${node.id}`, `📖 Recalled my notes on: ${node.name}`);
+    } catch (e) { /* announcements are best-effort */ }
+  };
+
   let args;
   try {
     args = await buildClaudeArgs(prompt, opts);
@@ -1009,6 +1024,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
             else currentToolDetail = "";
             noteSkillToolUse(block.name, input);
             if (block.name === "Bash" && input.command) noteRecallFromShell(input.command);
+            else if (block.name === "Read") noteRecallFromReadPath(input.file_path || input.filePath);
           }
         }
       }
@@ -1021,7 +1037,9 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           if (a.command) noteRecallFromShell(a.command);
         } else if (tc.readToolCall) {
           currentTool = "Read"; toolUses.push("Read");
-          currentToolDetail = (tc.readToolCall.args?.path || "").split("/").slice(-2).join("/");
+          const readPath = tc.readToolCall.args?.path;
+          currentToolDetail = (readPath || "").split("/").slice(-2).join("/");
+          noteRecallFromReadPath(readPath);
         } else if (tc.editToolCall) {
           currentTool = "Edit"; toolUses.push("Edit");
           currentToolDetail = (tc.editToolCall.args?.filePath || "").split("/").slice(-2).join("/");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.40",
+  "version": "2.6.42",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {
@@ -9,7 +9,7 @@
   "scripts": {
     "setup": "node setup.js",
     "start": "node bot.js",
-    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-pack-nesting.js"
+    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-pack-nesting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-read-signal.js"
   },
   "files": [
     "bot.js",
@@ -42,7 +42,8 @@
     "test-ability-tiers.js",
     "test-ability-merge-guard.js",
     "test-learning-e2e.js",
-    "test-pack-nesting.js"
+    "test-pack-nesting.js",
+    "test-read-signal.js"
   ],
   "keywords": [
     "claude",

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()) {

package/test-read-signal.js

@@ -0,0 +1,57 @@
+// Read-time recall signal: a Read of a pack/entity .md must resolve to the
+// right memory node so the runner can fire "📖 Recalled my notes on …" (and
+// reinforce the co-use graph) even when the agent reads the raw file directly
+// instead of going through `open-claudia pack show` / `entity show`.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "read-signal-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+process.env.ENTITIES_DIR = path.join(tmp, "entities");
+
+const packs = require("./core/packs");
+const entities = require("./core/entities");
+const { recallNodeFromPath } = require("./core/recall/read-signal");
+
+// ── a pack PACK.md resolves to its pack node (display name preferred) ──
+packs.createPack({ dir: "billing-invoices", name: "Billing Invoices", description: "invoice generation" });
+const packPath = path.join(process.env.PACKS_DIR, "billing-invoices", "PACK.md");
+assert.deepStrictEqual(
+  recallNodeFromPath(packPath),
+  { kind: "pack", id: "billing-invoices", name: "Billing Invoices" },
+  "pack path → pack node carrying the display name"
+);
+
+// ── an entity .md resolves to its entity node ──
+entities.upsertEntity({ name: "David Omondi", type: "person", description: "store keeper" });
+const entPath = path.join(process.env.ENTITIES_DIR, "david-omondi.md");
+assert.deepStrictEqual(
+  recallNodeFromPath(entPath),
+  { kind: "entity", id: "david-omondi", name: "David Omondi" },
+  "entity path → entity node carrying the display name"
+);
+
+// ── a node that isn't on disk still resolves by id (name falls back to id) ──
+assert.deepStrictEqual(
+  recallNodeFromPath(path.join(process.env.PACKS_DIR, "ghost-pack", "PACK.md")),
+  { kind: "pack", id: "ghost-pack", name: "ghost-pack" },
+  "missing pack falls back to id as name"
+);
+
+// ── anything that isn't a pack/entity file resolves to nothing ──
+assert.strictEqual(recallNodeFromPath(null), null, "null path → null");
+assert.strictEqual(recallNodeFromPath("/etc/passwd"), null, "outside the memory dirs → null");
+assert.strictEqual(
+  recallNodeFromPath(path.join(process.env.PACKS_DIR, "billing-invoices", "notes.md")),
+  null,
+  "a non-PACK.md file inside a pack dir → null"
+);
+assert.strictEqual(
+  recallNodeFromPath(path.join(process.env.ENTITIES_DIR, "sub", "deep.md")),
+  null,
+  "an entity .md in a subdir → null"
+);
+
+console.log("read signal OK");