@inetafrica/open-claudia 2.6.58 → 2.7.0

package/core/recall/metrics.js

@@ -10,7 +10,13 @@ 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 NODE_STATS_FILE = path.join(CONFIG_DIR, "recall-node-stats.json");
+const KPI_FILE = path.join(CONFIG_DIR, "recall-kpi.jsonl");
+let VERSION = "";
+try { VERSION = require("../../package.json").version || ""; } catch (e) {}
 const MAX_OPEN_TRACK = 400; // recent turns kept to reconcile surfaced→opened
+const MAX_NODES = 800; // node-stats map cap; lowest-activity entries pruned past this
+const MAX_CO_RESCUE = 300;
 
 function enabled() {
   return String(process.env.RECALL_METRICS || "on").toLowerCase() !== "off";
@@ -18,19 +24,24 @@ function enabled() {
 
 // Record one recall turn. `entry`:
 //   { engine, query, tier, seeds:[{id,score}], activated:[{id,activation,hop}],
-//     kept:[{id,why}], gated (bool), latencyMs, seedMs, expandMs, walkerMs,
+//     cand:[{id,act}], kept:[{id,why}], auto:{kept:[],dropped:[],shadow:{checks,agree}},
+//     gated (bool), latencyMs, seedMs, expandMs, walkerMs,
 //     walker ("warm"|"cold"|"off"|"failed"), costUsd }
 function logTurn(entry) {
   if (!enabled()) return;
   try {
     const rec = {
       ts: new Date().toISOString(),
+      v: VERSION,
+      model: entry.model || "",
       engine: entry.engine || "discoverer",
       query: String(entry.query || "").slice(0, 200),
       tier: entry.tier || "",
       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 })),
+      cand: (entry.cand || []).map((c) => ({ id: c.id, act: !!c.act })),
       kept: (entry.kept || []).map((k) => ({ id: k.id, why: String(k.why || "").slice(0, 200) })),
+      auto: entry.auto || null,
       gated: !!entry.gated,
       latencyMs: entry.latencyMs || 0,
       seedMs: entry.seedMs || 0,
@@ -41,6 +52,7 @@ function logTurn(entry) {
     };
     fs.appendFileSync(LOG_FILE, JSON.stringify(rec) + "\n");
     bumpSummary(rec);
+    bumpNodeStats(rec);
   } catch (e) {}
 }
 
@@ -54,16 +66,48 @@ function logUse(openedIds, source) {
   const ids = [...new Set((openedIds || []).filter(Boolean))];
   if (!ids.length) return;
   try {
-    const rec = { ts: new Date().toISOString(), use: ids };
+    const rec = { ts: new Date().toISOString(), v: VERSION, use: ids };
     if (source) rec.source = String(source);
     fs.appendFileSync(LOG_FILE, JSON.stringify(rec) + "\n");
     const s = readSummary();
-    s.opens = (s.opens || 0) + ids.length;
+    if (source === "reviewer") s.reviewerUses = (s.reviewerUses || 0) + ids.length;
+    else s.opens = (s.opens || 0) + ids.length;
+    writeSummary(s);
+    const ns = readNodeStats();
+    for (const id of ids) {
+      const n = nodeEntry(ns, id);
+      if (source === "reviewer") n.rev = (n.rev || 0) + 1;
+      else n.open = (n.open || 0) + 1;
+      n.last = today();
+    }
+    writeNodeStats(ns);
+  } catch (e) {}
+}
+
+// One walker-cascade shadow sample compared: the deterministic verdict vs the
+// judge's. Divergence here is what tells the dream to distrust the cascade.
+function logShadow(agree) {
+  if (!enabled()) return;
+  try {
+    const s = readSummary();
+    s.shadowChecks = (s.shadowChecks || 0) + 1;
+    if (agree) s.shadowAgree = (s.shadowAgree || 0) + 1;
+    writeSummary(s);
+  } catch (e) {}
+}
+
+// Reviewer skip-gate fired: a turn deterministically judged not memory-worthy.
+function logReviewerSkip() {
+  if (!enabled()) return;
+  try {
+    const s = readSummary();
+    s.reviewerSkipped = (s.reviewerSkipped || 0) + 1;
     writeSummary(s);
   } catch (e) {}
 }
 
 function round(n) { return Math.round((Number(n) || 0) * 1000) / 1000; }
+function today() { return new Date().toISOString().slice(0, 10); }
 
 function readSummary() {
   try { return JSON.parse(fs.readFileSync(SUMMARY_FILE, "utf8")) || {}; } catch (e) { return {}; }
@@ -72,6 +116,79 @@ function writeSummary(s) {
   try { fs.writeFileSync(SUMMARY_FILE, JSON.stringify(s, null, 2)); } catch (e) {}
 }
 
+function readNodeStats() {
+  try { return JSON.parse(fs.readFileSync(NODE_STATS_FILE, "utf8")) || { nodes: {}, coRescue: {} }; }
+  catch (e) { return { nodes: {}, coRescue: {} }; }
+}
+function writeNodeStats(ns) {
+  try {
+    pruneNodeStats(ns);
+    ns.updatedAt = new Date().toISOString();
+    fs.writeFileSync(NODE_STATS_FILE, JSON.stringify(ns));
+  } catch (e) {}
+}
+function nodeEntry(ns, id) {
+  ns.nodes = ns.nodes || {};
+  if (!ns.nodes[id]) ns.nodes[id] = { seen: 0, act: 0, kept: 0, open: 0, rev: 0, resc: 0 };
+  return ns.nodes[id];
+}
+function pruneNodeStats(ns) {
+  const ids = Object.keys(ns.nodes || {});
+  if (ids.length > MAX_NODES) {
+    const scored = ids.map((id) => {
+      const n = ns.nodes[id];
+      return { id, w: (n.seen || 0) + (n.kept || 0) * 3 + (n.open || 0) * 3 + (n.rev || 0) * 3 };
+    }).sort((a, b) => a.w - b.w);
+    for (const { id } of scored.slice(0, ids.length - MAX_NODES)) delete ns.nodes[id];
+  }
+  const pairs = Object.entries(ns.coRescue || {});
+  if (pairs.length > MAX_CO_RESCUE) {
+    ns.coRescue = Object.fromEntries(pairs.sort((a, b) => b[1] - a[1]).slice(0, MAX_CO_RESCUE));
+  }
+}
+
+// Per-node rolling counters — the evidence base for the walker cascade
+// (keep-rates), negative Hebbian (activated-never-kept), and dream targeting.
+// seen = surfaced as a candidate; act = of those, arrived via graph expansion;
+// kept = walker/cascade kept it; open/rev = actually used; resc = kept without
+// a seed match (graph rescue).
+function bumpNodeStats(rec) {
+  if (rec.gated) return;
+  const ns = readNodeStats();
+  const keptIds = new Set(rec.kept.map((k) => k.id));
+  const seedIds = new Set(rec.seeds.map((x) => x.id));
+  const candList = rec.cand && rec.cand.length
+    ? rec.cand
+    : [...rec.seeds.map((s) => ({ id: s.id, act: false })), ...rec.activated.map((a) => ({ id: a.id, act: true }))];
+  const seenIds = new Set();
+  for (const c of candList) {
+    if (seenIds.has(c.id) || c.id.startsWith("episode:")) continue;
+    seenIds.add(c.id);
+    const n = nodeEntry(ns, c.id);
+    n.seen++;
+    if (c.act) n.act++;
+    if (keptIds.has(c.id)) n.kept++;
+    n.last = today();
+  }
+  const rescued = [];
+  for (const k of rec.kept) {
+    if (k.id.startsWith("episode:")) continue;
+    if (!seenIds.has(k.id)) { const n = nodeEntry(ns, k.id); n.seen++; n.kept++; n.last = today(); }
+    if (!seedIds.has(k.id)) { nodeEntry(ns, k.id).resc++; rescued.push(k.id); }
+  }
+  // Co-rescue pairs: nodes repeatedly rescued together are missing a direct
+  // edge — the dream adds one deterministically past a threshold.
+  rescued.sort();
+  ns.coRescue = ns.coRescue || {};
+  for (let i = 0; i < rescued.length; i++) {
+    for (let j = i + 1; j < rescued.length; j++) {
+      const key = `${rescued[i]}|${rescued[j]}`;
+      ns.coRescue[key] = (ns.coRescue[key] || 0) + 1;
+    }
+  }
+  writeNodeStats(ns);
+}
+
 function bumpSummary(rec) {
   const s = readSummary();
   s.turns = (s.turns || 0) + 1;
@@ -86,6 +203,16 @@ function bumpSummary(rec) {
   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);
+  if (rec.tier) {
+    s.byTier = s.byTier || {};
+    const t = s.byTier[rec.tier] || { n: 0, ms: 0 };
+    t.n++; t.ms += rec.latencyMs || 0;
+    s.byTier[rec.tier] = t;
+  }
+  if (rec.auto) {
+    s.autoKept = (s.autoKept || 0) + ((rec.auto.kept || []).length);
+    s.autoDropped = (s.autoDropped || 0) + ((rec.auto.dropped || []).length);
+  }
   s.updatedAt = new Date().toISOString();
   writeSummary(s);
 }
@@ -108,15 +235,82 @@ function summary() {
     rescuePct: fmtPct(s.rescueTurns || 0, turns),
     rescues: s.rescues || 0,
     opens: s.opens || 0,
+    reviewerUses: s.reviewerUses || 0,
+    reviewerSkipped: s.reviewerSkipped || 0,
+    autoKept: s.autoKept || 0,
+    autoDropped: s.autoDropped || 0,
+    shadowChecks: s.shadowChecks || 0,
+    shadowAgreePct: fmtPct(s.shadowAgree || 0, s.shadowChecks || 0),
+    byTier: Object.fromEntries(Object.entries(s.byTier || {}).map(([t, v]) => [t, { turns: v.n, avgMs: v.n ? Math.round(v.ms / v.n) : 0 }])),
     avgLatencyMs: turns ? Math.round((s.latencyMsTotal || 0) / turns) : 0,
     costUsd: s.costUsd || 0,
     updatedAt: s.updatedAt || "",
   };
 }
 
+function nodeStats() { return readNodeStats(); }
+
+// Dream-facing evidence pack: raw summary (for windowed deltas against a prior
+// snapshot) plus targeted node lists the consolidation/tuning passes act on.
+function evidence({ minSeen = 6, coRescueMin = 3 } = {}) {
+  const s = readSummary();
+  const ns = readNodeStats();
+  const nodes = ns.nodes || {};
+  const neverKept = [];
+  const highKeep = [];
+  const topRescued = [];
+  for (const [id, n] of Object.entries(nodes)) {
+    const used = (n.open || 0) + (n.rev || 0);
+    if ((n.seen || 0) >= minSeen && (n.kept || 0) === 0 && used === 0) {
+      neverKept.push({ id, seen: n.seen, act: n.act || 0 });
+    }
+    if ((n.seen || 0) >= 5 && (n.kept || 0) / n.seen >= 0.8 && used >= 1) {
+      highKeep.push({ id, seen: n.seen, kept: n.kept, used });
+    }
+    if ((n.resc || 0) >= 2) topRescued.push({ id, rescues: n.resc });
+  }
+  neverKept.sort((a, b) => b.seen - a.seen);
+  topRescued.sort((a, b) => b.rescues - a.rescues);
+  const coRescuePairs = Object.entries(ns.coRescue || {})
+    .filter(([, n]) => n >= coRescueMin)
+    .map(([key, n]) => { const [a, b] = key.split("|"); return { a, b, n }; })
+    .sort((x, y) => y.n - x.n);
+  return {
+    summary: s,
+    neverKept: neverKept.slice(0, 25),
+    highKeep: highKeep.slice(0, 25),
+    topRescued: topRescued.slice(0, 15),
+    coRescuePairs: coRescuePairs.slice(0, 15),
+  };
+}
+
+// One version-stamped KPI snapshot per dream night. This is the durable
+// series `open-claudia kpi` aggregates to compare harness versions/models —
+// per-turn ground truth stays in LOG_FILE, this is the cheap nightly rollup.
+function appendKpi(snapshot) {
+  if (!enabled()) return;
+  try {
+    fs.appendFileSync(KPI_FILE, JSON.stringify({ ts: new Date().toISOString(), v: VERSION, ...snapshot }) + "\n");
+  } catch (e) {}
+}
+
+function readKpi() {
+  try {
+    return fs.readFileSync(KPI_FILE, "utf8").split("\n").filter(Boolean).map((l) => {
+      try { return JSON.parse(l); } catch (e) { return null; }
+    }).filter(Boolean);
+  } catch (e) { return []; }
+}
+
 function _resetForTest() {
   try { fs.rmSync(LOG_FILE, { force: true }); } catch (e) {}
   try { fs.rmSync(SUMMARY_FILE, { force: true }); } catch (e) {}
+  try { fs.rmSync(NODE_STATS_FILE, { force: true }); } catch (e) {}
+  try { fs.rmSync(KPI_FILE, { force: true }); } catch (e) {}
 }
 
-module.exports = { LOG_FILE, SUMMARY_FILE, enabled, logTurn, logUse, summary, _resetForTest };
+module.exports = {
+  LOG_FILE, SUMMARY_FILE, NODE_STATS_FILE, KPI_FILE, VERSION, enabled,
+  logTurn, logUse, logShadow, logReviewerSkip, appendKpi, readKpi,
+  summary, nodeStats, evidence, _resetForTest,
+};

package/core/recall/tuning.js

@@ -0,0 +1,125 @@
+// Dream-tunable recall knobs. The nightly dream is the ONLY writer; recall
+// paths read lazily (mtime-cached) so a knob change applies without a bot
+// restart. Every knob is hard-bounded here — a wild model proposal can never
+// push a value outside its safe range. Precedence: env var (operator pin)
+// > tuning file (dream) > default.
+
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../../config-dir");
+
+const TUNING_FILE = path.join(CONFIG_DIR, "recall-tuning.json");
+const MAX_HISTORY = 40;
+
+// name -> { def, min, max, env } (numeric) or { def, values, env } (enum).
+const KNOBS = {
+  walkerMaxCandidates: { def: 14, min: 8, max: 20, env: "RECALL_WALKER_MAX_CANDIDATES" },
+  episodeLimit: { def: 3, min: 1, max: 5, env: "RECALL_EPISODE_LIMIT" },
+  seedsTierMaxWords: { def: 4, min: 2, max: 6, env: "RECALL_SEEDS_TIER_MAX_WORDS" },
+  decayHalfLifeDays: { def: 60, min: 10, max: 90, env: "RECALL_DECAY_HALF_LIFE_DAYS" },
+  cascade: { def: "on", values: ["on", "off"], env: "RECALL_CASCADE" },
+};
+
+let _cache = null;
+let _cacheMtime = -1;
+
+function readFile() {
+  let mtime = 0;
+  try { mtime = fs.statSync(TUNING_FILE).mtimeMs; } catch (e) { mtime = 0; }
+  if (_cache && mtime === _cacheMtime) return _cache;
+  let data = {};
+  try { data = JSON.parse(fs.readFileSync(TUNING_FILE, "utf8")) || {}; } catch (e) { data = {}; }
+  _cache = data;
+  _cacheMtime = mtime;
+  return data;
+}
+
+function clampKnob(name, value) {
+  const spec = KNOBS[name];
+  if (!spec) return null;
+  if (spec.values) {
+    const v = String(value).toLowerCase();
+    return spec.values.includes(v) ? v : spec.def;
+  }
+  const n = Number(value);
+  if (!Number.isFinite(n)) return spec.def;
+  return Math.min(spec.max, Math.max(spec.min, n));
+}
+
+// Effective value of a knob, honouring env pin > tuning file > default.
+function get(name) {
+  const spec = KNOBS[name];
+  if (!spec) return undefined;
+  if (spec.env && process.env[spec.env] !== undefined && process.env[spec.env] !== "") {
+    return clampKnob(name, process.env[spec.env]);
+  }
+  const data = readFile();
+  if (data.knobs && data.knobs[name] !== undefined) return clampKnob(name, data.knobs[name]);
+  return spec.def;
+}
+
+function knobTable() {
+  return Object.entries(KNOBS).map(([name, spec]) => ({
+    name,
+    current: get(name),
+    default: spec.def,
+    min: spec.min,
+    max: spec.max,
+    values: spec.values,
+    pinned: !!(spec.env && process.env[spec.env]),
+  }));
+}
+
+// Dream-only writer. Applies ONE bounded change with provenance; returns the
+// applied {knob, from, to} or null when rejected (unknown knob / no-op / env-pinned).
+function set(name, value, { reason = "", evidence = "" } = {}) {
+  const spec = KNOBS[name];
+  if (!spec) return null;
+  if (spec.env && process.env[spec.env]) return null; // operator pin wins — don't fight it
+  const from = get(name);
+  const to = clampKnob(name, value);
+  if (to === from) return null;
+  const data = readFile();
+  data.knobs = data.knobs || {};
+  data.knobs[name] = to;
+  data.history = data.history || [];
+  data.history.push({ ts: new Date().toISOString(), knob: name, from, to, reason: String(reason).slice(0, 300), evidence: String(evidence).slice(0, 300) });
+  data.history = data.history.slice(-MAX_HISTORY);
+  write(data);
+  return { knob: name, from, to };
+}
+
+// Revert the most recent change of a knob (auto-rollback path).
+function revert(name, { reason = "" } = {}) {
+  const data = readFile();
+  if (!data.knobs || data.knobs[name] === undefined) return null;
+  const hist = (data.history || []).filter((h) => h.knob === name);
+  const last = hist[hist.length - 1];
+  if (!last) return null;
+  const from = data.knobs[name];
+  data.knobs[name] = clampKnob(name, last.from);
+  data.history.push({ ts: new Date().toISOString(), knob: name, from, to: data.knobs[name], reason: `rollback: ${reason}`.slice(0, 300) });
+  data.history = data.history.slice(-MAX_HISTORY);
+  write(data);
+  return { knob: name, from, to: data.knobs[name] };
+}
+
+function lastChange() {
+  const data = readFile();
+  const hist = (data.history || []).filter((h) => !/^rollback:/.test(h.reason || ""));
+  return hist[hist.length - 1] || null;
+}
+
+function history() { return readFile().history || []; }
+
+function write(data) {
+  try { fs.writeFileSync(TUNING_FILE, JSON.stringify(data, null, 2)); } catch (e) {}
+  _cache = null; _cacheMtime = -1;
+}
+
+function _resetForTest() {
+  try { fs.rmSync(TUNING_FILE, { force: true }); } catch (e) {}
+  _cache = null; _cacheMtime = -1;
+}
+
+module.exports = { TUNING_FILE, KNOBS, get, set, revert, lastChange, history, knobTable, clampKnob, _resetForTest };

package/core/runner.js

@@ -1027,10 +1027,12 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   // `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.)
+  let turnRecallTier = "";
   try {
     const injected = require("./system-prompt").consumeLastInjected();
     if (injected && injected.recall) {
       const r = injected.recall;
+      turnRecallTier = String(r.tier || "");
       const esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
       const fmt = (arr, icon) => arr.map((x) => (x.why ? `${icon} <b>${esc(x.name)}</b> — ${esc(x.why)}` : `${icon} <b>${esc(x.name)}</b>`));
       // 🧠 packs/entities recall — gated by /recall.
@@ -1517,10 +1519,12 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     // 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()) {
+      const WRITE_TOOLS = new Set(["Edit", "Write", "NotebookEdit", "Bash", "Shell", "Skill", "Task", "Agent"]);
       packReview.reviewTurn({
         userText: prompt,
         assistantText,
         channelId,
+        signals: { tier: turnRecallTier, wrote: toolUses.some((t) => WRITE_TOOLS.has(t)) },
         announce: (text) => chatContext.run(store, () => send(text)),
       });
     }

package/core/system-prompt.js

@@ -748,6 +748,7 @@ async function promptWithDynamicContext(prompt, opts = {}) {
     lastInjected.recall = {
       engine: engine.name || recall.activeEngineName(settings),
       gated: !!result.gated,
+      tier: result.tier || "",
       packs: (result.packMatches || []).map((m) => ({ name: m.name || m.dir, why: why[`pack:${m.dir}`] || "" })),
       entities: (result.entityMatches || []).map((m) => ({ name: m.name || m.slug, why: why[`entity:${m.slug}`] || "" })),
       // Tools surfaced as first-class discoverer nodes this turn (name + why).