@inetafrica/open-claudia 2.6.32 → 2.6.34

package/core/recall/graph.js

@@ -0,0 +1,366 @@
+// Typed-edge recall graph. One small SQLite table of weighted edges over the
+// shared corpus (packs + entities). Node ids are `pack:<dir>` / `entity:<slug>`.
+//
+// Edge types:
+//   parent       — hierarchy (kazee-mobile → kazee). Derived from pack `parent`.
+//   governed-by  — cross-cutting concern (kazee-mobile → kazee-theme). Derived
+//                  from [[links]] that point at a shared concern, or asserted.
+//   related      — soft association. Derived from [[links]] and reinforced by
+//                  co-use (Hebbian).
+//
+// Edges are stored directionally but traversed undirected. Each edge carries a
+// `weight` and `last_reinforced`. Structural edges (parent/related from pack
+// metadata) are re-derived idempotently; their weight floor is kept but any
+// extra reinforcement earned through use is preserved.
+
+const fs = require("fs");
+const path = require("path");
+
+let DatabaseSync = null;
+try { ({ DatabaseSync } = require("node:sqlite")); } catch (e) { /* old node — graph disabled */ }
+
+const CONFIG_DIR = require("../../config-dir");
+const GRAPH_DB = process.env.RECALL_GRAPH_DB
+  ? path.resolve(process.env.RECALL_GRAPH_DB)
+  : path.join(CONFIG_DIR, "recall-graph.db");
+
+const EDGE_TYPES = ["parent", "governed-by", "related"];
+
+// Base weights when an edge is first derived from structure.
+const BASE_WEIGHT = { parent: 3, "governed-by": 2.5, related: 1 };
+// Spreading-activation tunables (overridable via env / dream knobs).
+const DEFAULTS = {
+  hops: 2,
+  threshold: 0.18,   // firing threshold as a fraction of the strongest seed
+  damping: 0.55,     // fraction of activation transmitted per hop
+  perNodeTopK: 6,    // cap fan-out per node (sparsity)
+  maxWeight: 6,      // weight at which an edge transmits at full damping
+  halfLifeDays: 60,  // Hebbian weight half-life for decay()
+};
+
+let _db = null;
+
+function available() { return !!DatabaseSync; }
+
+function openDb() {
+  if (!DatabaseSync) return null;
+  if (_db) return _db;
+  try {
+    fs.mkdirSync(path.dirname(GRAPH_DB), { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(GRAPH_DB);
+    try { fs.chmodSync(GRAPH_DB, 0o600); } catch (e) {}
+    db.exec("PRAGMA journal_mode=WAL");
+    db.exec("PRAGMA busy_timeout=3000");
+    db.exec(`CREATE TABLE IF NOT EXISTS edges (
+      src TEXT NOT NULL,
+      dst TEXT NOT NULL,
+      type TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 1,
+      last_reinforced TEXT,
+      created TEXT,
+      PRIMARY KEY (src, dst, type)
+    )`);
+    db.exec("CREATE INDEX IF NOT EXISTS edges_src ON edges (src)");
+    db.exec("CREATE INDEX IF NOT EXISTS edges_dst ON edges (dst)");
+    _db = db;
+    return db;
+  } catch (e) {
+    return null;
+  }
+}
+
+function now() { return new Date().toISOString(); }
+
+function normType(t) {
+  const s = String(t || "").toLowerCase().trim();
+  return EDGE_TYPES.includes(s) ? s : "related";
+}
+
+// Upsert an edge. By default keeps the larger of the existing/new weight so a
+// structural re-derive never stomps reinforcement; pass `{ bump }` to add to
+// the current weight (Hebbian) and stamp last_reinforced.
+function addEdge(src, dst, type, opts = {}) {
+  const db = openDb();
+  if (!db || !src || !dst || src === dst) return false;
+  const t = normType(type);
+  const weight = Number.isFinite(opts.weight) ? opts.weight : (BASE_WEIGHT[t] || 1);
+  const bump = Number.isFinite(opts.bump) ? opts.bump : 0;
+  try {
+    const existing = db.prepare("SELECT weight FROM edges WHERE src=? AND dst=? AND type=?").get(src, dst, t);
+    if (existing) {
+      const next = bump ? existing.weight + bump : Math.max(existing.weight, weight);
+      const stamp = bump ? now() : null;
+      if (stamp) {
+        db.prepare("UPDATE edges SET weight=?, last_reinforced=? WHERE src=? AND dst=? AND type=?")
+          .run(next, stamp, src, dst, t);
+      } else {
+        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, src, dst, t);
+      }
+    } else {
+      db.prepare("INSERT INTO edges (src, dst, type, weight, last_reinforced, created) VALUES (?,?,?,?,?,?)")
+        .run(src, dst, t, weight + bump, bump ? now() : null, now());
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function removeEdge(src, dst, type) {
+  const db = openDb();
+  if (!db) return false;
+  try {
+    if (type) db.prepare("DELETE FROM edges WHERE src=? AND dst=? AND type=?").run(src, dst, normType(type));
+    else db.prepare("DELETE FROM edges WHERE src=? AND dst=?").run(src, dst);
+    return true;
+  } catch (e) { return false; }
+}
+
+function allEdges() {
+  const db = openDb();
+  if (!db) return [];
+  try { return db.prepare("SELECT src, dst, type, weight, last_reinforced FROM edges").all(); }
+  catch (e) { return []; }
+}
+
+// Undirected neighbours of a node: edges where it is src OR dst.
+function neighbors(nodeId) {
+  const db = openDb();
+  if (!db || !nodeId) return [];
+  try {
+    const rows = db.prepare(
+      "SELECT src, dst, type, weight FROM edges WHERE src=? OR dst=?"
+    ).all(nodeId, nodeId);
+    return rows.map((r) => ({
+      node: r.src === nodeId ? r.dst : r.src,
+      type: r.type,
+      weight: r.weight,
+    }));
+  } catch (e) { return []; }
+}
+
+// Hebbian co-use reinforcement. Called when two nodes are actually USED
+// together (📖 banner), not merely co-recalled. Bumps a `related` edge both
+// ways so traversal from either side benefits.
+function reinforce(a, b, amount = 1) {
+  if (!a || !b || a === b) return;
+  addEdge(a, b, "related", { bump: amount });
+  addEdge(b, a, "related", { bump: amount });
+}
+
+// Reinforce every unordered pair in a used set.
+function reinforceSet(nodeIds, amount = 1) {
+  const ids = [...new Set((nodeIds || []).filter(Boolean))];
+  for (let i = 0; i < ids.length; i++) {
+    for (let j = i + 1; j < ids.length; j++) reinforce(ids[i], ids[j], amount);
+  }
+}
+
+// Exponential time decay on reinforced weight. Structural floor is preserved:
+// an edge never decays below its type's base weight.
+function decay({ halfLifeDays = DEFAULTS.halfLifeDays } = {}) {
+  const db = openDb();
+  if (!db) return 0;
+  const rows = allEdges();
+  const nowMs = Date.now();
+  const ln2 = Math.log(2);
+  let changed = 0;
+  for (const e of rows) {
+    if (!e.last_reinforced) continue;
+    const ageDays = (nowMs - Date.parse(e.last_reinforced)) / 86400000;
+    if (!(ageDays > 0)) continue;
+    const factor = Math.exp(-ln2 * ageDays / Math.max(1, halfLifeDays));
+    const floor = BASE_WEIGHT[e.type] || 0;
+    const next = Math.max(floor, e.weight * factor);
+    if (Math.abs(next - e.weight) > 1e-6) {
+      try {
+        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?")
+          .run(next, e.src, e.dst, e.type);
+        changed++;
+      } catch (e2) {}
+    }
+  }
+  return changed;
+}
+
+// Spreading activation. `seeds` is [{ id, score }] (score = match strength).
+// Returns Map id -> { activation, hop, via } for nodes that fired above the
+// threshold, EXCLUDING the original seeds (those are already in the result set
+// the caller seeded from). Pure in-memory over an adjacency snapshot.
+function expand(seeds, opts = {}) {
+  const o = { ...DEFAULTS, ...opts };
+  const out = new Map();
+  const seedList = (seeds || []).filter((s) => s && s.id);
+  if (!seedList.length || !available()) return out;
+
+  // Build adjacency once, keeping the strongest edge per (node, neighbour).
+  const adj = new Map();
+  for (const e of allEdges()) {
+    const w = e.weight;
+    const push = (from, to) => {
+      if (!adj.has(from)) adj.set(from, new Map());
+      const m = adj.get(from);
+      if (!m.has(to) || m.get(to) < w) m.set(to, w);
+    };
+    push(e.src, e.dst);
+    push(e.dst, e.src);
+  }
+
+  const maxSeed = Math.max(...seedList.map((s) => Number(s.score) || 1), 1);
+  const fireThreshold = o.threshold * maxSeed;
+  const activation = new Map();
+  const seedIds = new Set(seedList.map((s) => s.id));
+  let frontier = [];
+  for (const s of seedList) {
+    const a = Number(s.score) || 1;
+    activation.set(s.id, a);
+    frontier.push({ id: s.id, a });
+  }
+
+  for (let hop = 1; hop <= o.hops && frontier.length; hop++) {
+    const next = new Map();
+    for (const { id, a } of frontier) {
+      const m = adj.get(id);
+      if (!m) continue;
+      // top-k strongest neighbours (sparsity)
+      const ranked = [...m.entries()].sort((x, y) => y[1] - x[1]).slice(0, o.perNodeTopK);
+      for (const [nb, w] of ranked) {
+        const transmit = a * (Math.min(w, o.maxWeight) / o.maxWeight) * o.damping;
+        if (transmit <= 0) continue;
+        const prev = activation.get(nb) || 0;
+        const sum = prev + transmit;
+        activation.set(nb, sum);
+        if (!seedIds.has(nb) && sum >= fireThreshold) {
+          const cur = out.get(nb);
+          if (!cur || cur.activation < sum) out.set(nb, { activation: sum, hop, via: id });
+          // only freshly-fired nodes propagate onward
+          const best = next.get(nb) || 0;
+          if (transmit > best) next.set(nb, transmit);
+        }
+      }
+    }
+    frontier = [...next.entries()].map(([id, a]) => ({ id, a }));
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Structural sync: derive edges from the corpus so the graph is never empty
+// even before any reinforcement. Idempotent — re-runnable any time.
+//   pack `parent` frontmatter            → parent edge (child → parent)
+//   [[link]] in any pack/entity body     → related edge (or governed-by if the
+//                                          target is tagged a shared concern)
+// Existing reinforced weights are preserved (addEdge keeps the max).
+
+function parseLinks(text) {
+  const out = [];
+  const re = /\[\[([^\]]+)\]\]/g;
+  let m;
+  while ((m = re.exec(String(text || "")))) {
+    const slug = m[1].trim().toLowerCase();
+    if (slug) out.push(slug);
+  }
+  return out;
+}
+
+function isSharedConcern(pack) {
+  const tags = (pack.tags || []).map((t) => t.toLowerCase());
+  return tags.includes("shared") || tags.includes("concern") || tags.includes("cross-cutting");
+}
+
+function syncFromCorpus(packsLib, entitiesLib) {
+  if (!openDb()) return { edges: 0 };
+  let packs = [];
+  let entities = [];
+  try { packs = packsLib.listPacks(); } catch (e) {}
+  try { entities = entitiesLib ? entitiesLib.listEntities() : []; } catch (e) {}
+
+  const packByDir = new Map(packs.map((p) => [p.dir, p]));
+  const packByName = new Map(packs.map((p) => [p.name.toLowerCase(), p]));
+  const entBySlug = new Map(entities.map((e) => [e.slug, e]));
+  const entByName = new Map(entities.map((e) => [e.name.toLowerCase(), e]));
+
+  const resolve = (token) => {
+    if (packByDir.has(token)) return `pack:${token}`;
+    if (packByName.has(token)) return `pack:${packByName.get(token).dir}`;
+    if (entBySlug.has(token)) return `entity:${token}`;
+    if (entByName.has(token)) return `entity:${entByName.get(token).slug}`;
+    return null;
+  };
+
+  let count = 0;
+  for (const p of packs) {
+    const id = `pack:${p.dir}`;
+    if (p.parent) {
+      const parentId = resolve(String(p.parent).toLowerCase());
+      if (parentId && addEdge(id, parentId, "parent")) count++;
+    }
+    const body = [p.sections.Stance, p.sections.Procedure, p.sections.State, p.sections.Journal].join("\n");
+    for (const link of parseLinks(body)) {
+      const target = resolve(link);
+      if (!target || target === id) continue;
+      const targetPack = target.startsWith("pack:") ? packByDir.get(target.slice(5)) : null;
+      const type = targetPack && isSharedConcern(targetPack) ? "governed-by" : "related";
+      if (addEdge(id, target, type)) count++;
+    }
+  }
+  for (const e of entities) {
+    const id = `entity:${e.slug}`;
+    const body = [e.sections.Notes, e.sections.Log].join("\n");
+    for (const link of parseLinks(body)) {
+      const target = resolve(link);
+      if (!target || target === id) continue;
+      if (addEdge(id, target, "related")) count++;
+    }
+  }
+  return { edges: count };
+}
+
+// Prune edges whose endpoints no longer exist in the corpus (a pack/entity was
+// removed or archived). Keeps the graph from accumulating dangling links.
+function pruneOrphans(packsLib, entitiesLib) {
+  const db = openDb();
+  if (!db) return 0;
+  const live = new Set();
+  try { for (const p of packsLib.listPacks()) live.add(`pack:${p.dir}`); } catch (e) {}
+  try { for (const e of (entitiesLib ? entitiesLib.listEntities() : [])) live.add(`entity:${e.slug}`); } catch (e) {}
+  if (!live.size) return 0;
+  let removed = 0;
+  for (const e of allEdges()) {
+    if (!live.has(e.src) || !live.has(e.dst)) {
+      if (removeEdge(e.src, e.dst, e.type)) removed++;
+    }
+  }
+  return removed;
+}
+
+// Nightly maintenance: refresh structural edges, decay reinforced weights,
+// drop orphans. Deterministic + safe — the high-judgment "extract shared
+// concern node" surgery is left to the dream model proper.
+function tend(packsLib, entitiesLib, opts = {}) {
+  const synced = syncFromCorpus(packsLib, entitiesLib);
+  const decayed = decay(opts);
+  const pruned = pruneOrphans(packsLib, entitiesLib);
+  return { synced: synced.edges, decayed, pruned, ...stats() };
+}
+
+function stats() {
+  const rows = allEdges();
+  const byType = {};
+  for (const e of rows) byType[e.type] = (byType[e.type] || 0) + 1;
+  const nodes = new Set();
+  for (const e of rows) { nodes.add(e.src); nodes.add(e.dst); }
+  return { edges: rows.length, nodes: nodes.size, byType };
+}
+
+// Test seam.
+function _resetForTest() { if (_db) { try { _db.close(); } catch (e) {} } _db = null; }
+
+module.exports = {
+  EDGE_TYPES, DEFAULTS, GRAPH_DB,
+  available, openDb,
+  addEdge, removeEdge, allEdges, neighbors,
+  reinforce, reinforceSet, decay, expand,
+  syncFromCorpus, parseLinks, pruneOrphans, tend, stats,
+  _resetForTest,
+};

package/core/recall/index.js

@@ -0,0 +1,33 @@
+// Recall engine registry + selector.
+//
+// One shared corpus (packs/entities), multiple pluggable retrieval engines.
+// Each engine implements: async run(ctx) -> { packBlock, entityBlock,
+// packMatches, entityMatches }. The active engine is chosen per channel via
+// the `recallEngine` setting (set by the /engine slash command), falling back
+// to the RECALL_ENGINE env var, then to "classic". Unknown names fall back to
+// classic so a bad value can never break recall.
+
+const classic = require("./classic");
+const discoverer = require("./discoverer");
+
+const ENGINES = {
+  classic,
+  discoverer,
+};
+
+function listEngines() {
+  return Object.keys(ENGINES);
+}
+
+function activeEngineName(settings) {
+  const fromSettings = settings && settings.recallEngine;
+  const fromEnv = process.env.RECALL_ENGINE;
+  const name = String(fromSettings || fromEnv || "classic").toLowerCase();
+  return ENGINES[name] ? name : "classic";
+}
+
+function getEngine(name) {
+  return ENGINES[name] || classic;
+}
+
+module.exports = { ENGINES, listEngines, activeEngineName, getEngine };

package/core/recall/metrics.js

@@ -0,0 +1,109 @@
+// Recall metrics. One JSONL line per discoverer turn plus a rolling summary,
+// so we can compute precision (surfaced→used), miss-rescue rate, and noise
+// (surfaced-but-never-opened) over time and let the dream tune knobs against
+// real numbers. Engine-agnostic: the classic engine keeps its own legacy
+// recall-debug.jsonl; this is the richer log the discoverer engine writes.
+
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../../config-dir");
+
+const LOG_FILE = path.join(CONFIG_DIR, "recall-metrics.jsonl");
+const SUMMARY_FILE = path.join(CONFIG_DIR, "recall-metrics-summary.json");
+const MAX_OPEN_TRACK = 400; // recent turns kept to reconcile surfaced→opened
+
+function enabled() {
+  return String(process.env.RECALL_METRICS || "on").toLowerCase() !== "off";
+}
+
+// Record one recall turn. `entry`:
+//   { engine, query, seeds:[{id,score}], activated:[{id,activation,hop}],
+//     kept:[{id,why}], gated (bool), latencyMs, costUsd }
+function logTurn(entry) {
+  if (!enabled()) return;
+  try {
+    const rec = {
+      ts: new Date().toISOString(),
+      engine: entry.engine || "discoverer",
+      query: String(entry.query || "").slice(0, 200),
+      seeds: (entry.seeds || []).map((s) => ({ id: s.id, score: s.score })),
+      activated: (entry.activated || []).map((a) => ({ id: a.id, activation: round(a.activation), hop: a.hop })),
+      kept: (entry.kept || []).map((k) => ({ id: k.id, why: String(k.why || "").slice(0, 200) })),
+      gated: !!entry.gated,
+      latencyMs: entry.latencyMs || 0,
+      costUsd: entry.costUsd || 0,
+    };
+    fs.appendFileSync(LOG_FILE, JSON.stringify(rec) + "\n");
+    bumpSummary(rec);
+  } catch (e) {}
+}
+
+// Record which nodes were actually opened (📖) this turn. Matched against the
+// most recent surfaced sets to derive precision/noise without a second pass
+// over the whole log.
+function logUse(openedIds) {
+  if (!enabled()) return;
+  const ids = [...new Set((openedIds || []).filter(Boolean))];
+  if (!ids.length) return;
+  try {
+    fs.appendFileSync(LOG_FILE, JSON.stringify({ ts: new Date().toISOString(), use: ids }) + "\n");
+    const s = readSummary();
+    s.opens = (s.opens || 0) + ids.length;
+    writeSummary(s);
+  } catch (e) {}
+}
+
+function round(n) { return Math.round((Number(n) || 0) * 1000) / 1000; }
+
+function readSummary() {
+  try { return JSON.parse(fs.readFileSync(SUMMARY_FILE, "utf8")) || {}; } catch (e) { return {}; }
+}
+function writeSummary(s) {
+  try { fs.writeFileSync(SUMMARY_FILE, JSON.stringify(s, null, 2)); } catch (e) {}
+}
+
+function bumpSummary(rec) {
+  const s = readSummary();
+  s.turns = (s.turns || 0) + 1;
+  if (rec.gated) s.gatedTurns = (s.gatedTurns || 0) + 1;
+  s.seedsTotal = (s.seedsTotal || 0) + rec.seeds.length;
+  s.activatedTotal = (s.activatedTotal || 0) + rec.activated.length;
+  s.keptTotal = (s.keptTotal || 0) + rec.kept.length;
+  // miss-rescue: a kept node that no seed matched (came purely from graph expansion)
+  const seedIds = new Set(rec.seeds.map((x) => x.id));
+  const rescues = rec.kept.filter((k) => !seedIds.has(k.id)).length;
+  if (rescues > 0) { s.rescueTurns = (s.rescueTurns || 0) + 1; s.rescues = (s.rescues || 0) + rescues; }
+  s.costUsd = round((s.costUsd || 0) + (rec.costUsd || 0));
+  s.latencyMsTotal = (s.latencyMsTotal || 0) + (rec.latencyMs || 0);
+  s.updatedAt = new Date().toISOString();
+  writeSummary(s);
+}
+
+// Human-readable stats view (rendered by `open-claudia recall-stats`).
+function summary() {
+  const s = readSummary();
+  const turns = s.turns || 0;
+  const fmtPct = (n, d) => (d ? `${Math.round((n / d) * 100)}%` : "—");
+  return {
+    turns,
+    gatedTurns: s.gatedTurns || 0,
+    gatedPct: fmtPct(s.gatedTurns || 0, turns),
+    avgSeeds: turns ? round((s.seedsTotal || 0) / turns) : 0,
+    avgActivated: turns ? round((s.activatedTotal || 0) / turns) : 0,
+    avgKept: turns ? round((s.keptTotal || 0) / turns) : 0,
+    rescueTurns: s.rescueTurns || 0,
+    rescuePct: fmtPct(s.rescueTurns || 0, turns),
+    rescues: s.rescues || 0,
+    opens: s.opens || 0,
+    avgLatencyMs: turns ? Math.round((s.latencyMsTotal || 0) / turns) : 0,
+    costUsd: s.costUsd || 0,
+    updatedAt: s.updatedAt || "",
+  };
+}
+
+function _resetForTest() {
+  try { fs.rmSync(LOG_FILE, { force: true }); } catch (e) {}
+  try { fs.rmSync(SUMMARY_FILE, { force: true }); } catch (e) {}
+}
+
+module.exports = { LOG_FILE, SUMMARY_FILE, enabled, logTurn, logUse, summary, _resetForTest };

package/core/runner.js

@@ -842,16 +842,46 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     } catch (e) { /* announcements are best-effort */ }
   };
 
+  // Read-side recall: fire "📖 Recalled my notes on …" only when the agent
+  // actually pulls a full pack/entity via the CLI (it decided it was worth
+  // reading), not when a headline was auto-injected. Deduped per turn through
+  // notifySkill's Set so repeated `pack show` calls don't spam the chat.
+  // Nodes the agent actually OPENED this turn (📖). This is the co-use signal
+  // the recall graph reinforces on — actually-read, not merely surfaced.
+  const openedThisTurn = new Set();
+  const noteRecallFromShell = (command) => {
+    try {
+      const cmd = String(command || "");
+      if (!cmd.includes("open-claudia")) return;
+      let m;
+      const packRe = /\bpack\s+show\s+["']?([a-z0-9][\w.-]*)/gi;
+      while ((m = packRe.exec(cmd))) {
+        const dir = m[1];
+        const pack = packsLib.readPack(dir);
+        const name = (pack && (pack.name || pack.dir)) || dir;
+        openedThisTurn.add(`pack:${dir}`);
+        notifySkill(`recall:pack:${dir}`, `📖 Recalled my notes on: ${name}`);
+      }
+      const entRe = /\bentity\s+show\s+["']?([a-z0-9][\w.-]*)/gi;
+      while ((m = entRe.exec(cmd))) {
+        const slug = m[1];
+        const ent = entitiesLib.readEntity(slug);
+        const name = (ent && (ent.name || ent.slug)) || slug;
+        openedThisTurn.add(`entity:${slug}`);
+        notifySkill(`recall:entity:${slug}`, `📖 Recalled my notes on: ${name}`);
+      }
+    } catch (e) { /* announcements are best-effort */ }
+  };
+
   const args = await buildClaudeArgs(prompt, opts);
-  // Recall announcements: mirror the write-side "🧠 jotted down" notes with
-  // a read-side line whenever packs/entities freshly enter context this turn.
-  try {
-    const { packs, entities } = require("./system-prompt").consumeLastInjected();
-    const recalled = [...packs, ...entities];
-    if (recalled.length > 0) {
-      chatContext.run(store, () => send(`📖 Recalled my notes on: ${recalled.join(", ")}`).catch(() => {}));
-    }
-  } catch (e) { /* announcements are best-effort */ }
+  // Recall announcements are now fired at READ time, not injection time:
+  // matched packs/entities enter context only as small headlines (see
+  // system-prompt.js recallHeadline). The "📖 Recalled my notes on …" line is
+  // emitted by noteRecallFromShell below when the agent actually runs
+  // `open-claudia pack show <dir>` / `entity show <slug>` — so the banner
+  // reflects what was read, not what was pushed. (consumeLastInjected is
+  // drained here to keep the per-turn buffer from leaking into the next turn.)
+  try { require("./system-prompt").consumeLastInjected(); } catch (e) { /* best-effort */ }
   const binaryPath = getActiveBinary();
   const proc = spawn(binaryPath, args, {
     cwd,
@@ -928,6 +958,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
             else if (block.name === "Skill" && input.skill) currentToolDetail = input.skill;
             else currentToolDetail = "";
             noteSkillToolUse(block.name, input);
+            if (block.name === "Bash" && input.command) noteRecallFromShell(input.command);
           }
         }
       }
@@ -937,6 +968,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           const a = tc.shellToolCall.args || {};
           currentTool = "Shell"; toolUses.push("Shell");
           currentToolDetail = (a.description || a.command || "").slice(0, 80);
+          if (a.command) noteRecallFromShell(a.command);
         } else if (tc.readToolCall) {
           currentTool = "Read"; toolUses.push("Read");
           currentToolDetail = (tc.readToolCall.args?.path || "").split("/").slice(-2).join("/");
@@ -983,6 +1015,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         if (it.type === "command_execution" && it.command) {
           currentTool = "Shell"; toolUses.push("Shell");
           currentToolDetail = String(it.command).slice(0, 80);
+          noteRecallFromShell(it.command);
         } else if (it.type === "file_change" && (it.path || it.file_path)) {
           currentTool = "Edit"; toolUses.push("Edit");
           const p = it.path || it.file_path;
@@ -1102,6 +1135,17 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     if (settings.budget) settings.budget = null;
     state.statusMessageId = null;
 
+    // Hebbian co-use: nodes the agent actually opened together this turn get
+    // their `related` edges reinforced, so future spreading activation pulls
+    // the cluster together. Reinforce on co-USE (📖), never co-recall.
+    if (openedThisTurn.size > 0) {
+      try {
+        const recallGraph = require("./recall/graph");
+        if (openedThisTurn.size > 1) recallGraph.reinforceSet([...openedThisTurn]);
+        require("./recall/metrics").logUse([...openedThisTurn]);
+      } catch (e) { /* best-effort */ }
+    }
+
     // Post-turn pack review: fire-and-forget on a cheap model; never
     // blocks queue drain or the next turn.
     if ((code === 0 || code === null) && assistantText.trim()) {

package/core/state.js

@@ -43,7 +43,7 @@ const savedState = (() => {
 const userStates = new Map();
 
 function freshSettings() {
-  return { model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude", compactWindow: null };
+  return { model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude", compactWindow: null, recallEngine: null };
 }
 
 function freshUsage() {