@inetafrica/open-claudia 2.6.33 → 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

@@ -846,6 +846,9 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   // 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 || "");
@@ -856,6 +859,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         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;
@@ -863,6 +867,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         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 */ }
@@ -1130,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() {

package/core/system-prompt.js

@@ -623,32 +623,19 @@ async function promptWithDynamicContext(prompt, opts = {}) {
     const fullContext = [contextText, historyText].filter(Boolean).join("\n\n");
     const packsLib = require("./packs");
     const entitiesLib = require("./entities");
-    let packMatches = [];
-    let entityMatches = [];
     const packLimit = packMatchLimit();
-    try {
-      packMatches = mergeMatches(
-        packsLib.matchPacks(userText, { limit: packLimit }),
-        fullContext ? packsLib.matchPacks(fullContext, { limit: packLimit }) : [],
-        (m) => m.dir,
-      );
-    } catch (e) {}
-    try {
-      entityMatches = mergeMatches(
-        entitiesLib.matchEntities(userText, { limit: 4 }),
-        fullContext ? entitiesLib.matchEntities(fullContext, { limit: 4 }) : [],
-        (m) => m.slug,
-      );
-    } catch (e) {}
-    const candPacks = packMatches;
-    const candEntities = entityMatches;
-    ({ packMatches, entityMatches } = await filterMatches(userText, fullContext, packMatches, entityMatches));
-    packMatches = packMatches.slice(0, packLimit);
-    entityMatches = entityMatches.slice(0, 4);
-    logRecall(userText, candPacks, candEntities, packMatches, entityMatches);
     const budget = memoryRecallBudget();
-    const packBlock = buildPackBlock(packMatches, budget);
-    const entityBlock = buildEntityBlock(entityMatches, budget);
+    let settings = {};
+    try { settings = currentState().settings || {}; } catch (e) {}
+    const recall = require("./recall");
+    const engine = recall.getEngine(recall.activeEngineName(settings));
+    const helpers = {
+      packsLib, entitiesLib, mergeMatches, filterMatches, logRecall,
+      buildPackBlock, buildEntityBlock,
+    };
+    const { packBlock, entityBlock } = await engine.run({
+      userText, contextText, fullContext, packLimit, budget, helpers,
+    });
     const budgetNote = budget.omitted > 0
       ? `\n\n## Memory budget\n${budget.omitted} matched memory item${budget.omitted === 1 ? " was" : "s were"} omitted to keep this turn under the recall budget (${budget.maxChars} chars). Use \`open-claudia pack show <dir>\`, \`entity show <slug>\`, or transcript search if deeper context is needed.`
       : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.33",
+  "version": "2.6.34",
   "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"
+    "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"
   },
   "files": [
     "bot.js",
@@ -30,7 +30,10 @@
     ".env.example",
     "README.md",
     "CHANGELOG.md",
-    "test-usage-accounting.js"
+    "test-usage-accounting.js",
+    "test-recall-engine.js",
+    "test-recall-graph.js",
+    "test-recall-discoverer.js"
   ],
   "keywords": [
     "claude",