@inetafrica/open-claudia 2.6.58 → 2.6.59

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).

package/core/transcript-index.js

@@ -145,6 +145,26 @@ function rebuild(transcriptsDir = defaultTranscriptsDir()) {
   return indexAll(transcriptsDir);
 }
 
+// Nightly upkeep: catch up new appends, then drop index rows for transcript
+// files that no longer exist on disk — dead sessions stop matching and the
+// FTS table stays proportional to what is actually recallable.
+function tend(transcriptsDir = defaultTranscriptsDir()) {
+  const db = open(transcriptsDir);
+  if (!db) return { available: false, added: 0, prunedFiles: 0 };
+  const { added } = indexAll(transcriptsDir);
+  let prunedFiles = 0;
+  try {
+    const rows = db.prepare("SELECT path FROM files").all();
+    for (const r of rows) {
+      if (fs.existsSync(r.path)) continue;
+      db.prepare("DELETE FROM entries WHERE file = ?").run(r.path);
+      db.prepare("DELETE FROM files WHERE path = ?").run(r.path);
+      prunedFiles++;
+    }
+  } catch (e) {}
+  return { available: true, added, prunedFiles };
+}
+
 // FTS5 MATCH chokes on unbalanced quotes/operators in natural queries, so
 // by default each term is quoted (implicit AND). Pass raw=true for full
 // FTS5 query syntax (NEAR, OR, prefix*).
@@ -184,4 +204,4 @@ function stats(transcriptsDir = defaultTranscriptsDir()) {
   }
 }
 
-module.exports = { available, open, indexFile, indexAll, rebuild, search, stats, sanitizeQuery, defaultTranscriptsDir };
+module.exports = { available, open, indexFile, indexAll, rebuild, tend, search, stats, sanitizeQuery, defaultTranscriptsDir };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.58",
+  "version": "2.6.59",
   "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-runner-watchdog-static.js && 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-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-graph.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-runner-watchdog-static.js && 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-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-evolution.js"
   },
   "files": [
     "bot.js",

package/test-recall-discoverer.js

@@ -1,6 +1,9 @@
 // Discoverer engine: pre-gate, seed → (graph) → fail-open injection. The LLM
 // walker is disabled here (RECALL_DISCOVERER_WALKER=off) so the engine takes
-// its deterministic fail-open path: keep user-origin seeds, drop guesses.
+// its deterministic fail-open path. Contract: the seeds tier keeps ALL
+// user-origin keyword seeds (packs, entities, tools); the full tier without a
+// judge keeps only the top-3 user-origin pack/entity seeds — an unjudged tool
+// or episode is a guess, not a memory.
 const assert = require("assert");
 const fs = require("fs");
 const os = require("os");
@@ -101,16 +104,28 @@ const helpers = { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEnti
   });
   assert.strictEqual(typeof out2.packBlock, "string");
 
-  // tool seeding: a tool matching the user text surfaces as a kept tool match and
-  // renders into toolBlock; a turn that matches no tool yields an empty toolBlock
+  // tool seeding (seeds tier): a ≤4-word command matching a tool keeps it as a
+  // user-origin seed and renders the toolBlock; no tool match → empty toolBlock
   const outTool = await disc.run({
-    userText: "audit the mikrotik router fleet", contextText: "",
-    fullContext: "audit the mikrotik router fleet", packLimit: 6, budget: {}, helpers,
+    userText: "audit mikrotik router fleet", contextText: "",
+    fullContext: "audit mikrotik router fleet", packLimit: 6, budget: {}, helpers,
   });
-  assert.ok(outTool.toolMatches.some((m) => m.name === "mikrotik-audit"), "matching tool is kept (fail-open user seed)");
+  assert.strictEqual(outTool.tier, "seeds", "4-word command lands on the seeds tier");
+  assert.ok(outTool.toolMatches.some((m) => m.name === "mikrotik-audit"), "matching tool is kept (seeds-tier user seed)");
   assert.ok(/mikrotik-audit/.test(outTool.toolBlock), "kept tool renders into the toolBlock");
   assert.ok(/Tools that may help here/.test(outTool.toolBlock), "toolBlock carries its heading");
 
+  // full-tier fail-open: with no judge, an unjudged TOOL is a guess — dropped.
+  // (Measured before the fix: a failed walk kept 15 unjudged seeds including
+  // WiFi tools for a dream question.) Pack/entity user seeds still inject.
+  const outToolFull = await disc.run({
+    userText: "audit the mikrotik router fleet inventory please", contextText: "",
+    fullContext: "audit the mikrotik router fleet inventory please", packLimit: 6, budget: {}, helpers,
+  });
+  assert.strictEqual(outToolFull.tier, "full", "substantive ask lands on the full tier");
+  assert.strictEqual(outToolFull.toolMatches.length, 0, "fail-open drops unjudged tools at full tier");
+  assert.strictEqual(outToolFull.toolBlock, "", "no unjudged toolBlock at full tier");
+
   const outNoTool = await disc.run({
     userText: "help with the mobile app", contextText: "", fullContext: "help with the mobile app",
     packLimit: 6, budget: {}, helpers,