@inetafrica/open-claudia 2.6.57 → 2.6.59

package/core/packs.js

@@ -343,8 +343,35 @@ function recordForegroundWrite(dir, { tool, oldString, content } = {}) {
   } catch (e) {}
 }
 
+// Near-duplicate check for journal appends. The reviewer runs after EVERY
+// substantial turn, so a long working session on one topic used to stack
+// dozens of same-day entries that only differ in phrasing (observed: 28 in a
+// day on one pack) — crowding real history out of the capped Journal. Token
+// Jaccard against the most recent entries; dates stripped before comparing.
+function journalTokens(s) {
+  return new Set(
+    String(s || "").toLowerCase()
+      .replace(/^-\s*\[[^\]]*\]\s*/, "")
+      .replace(/[^a-z0-9\s]/g, " ")
+      .split(/\s+/).filter((w) => w.length > 1)
+  );
+}
+
+function isNearDupJournal(line, recentEntries) {
+  const a = journalTokens(line);
+  if (!a.size) return false;
+  for (const e of recentEntries) {
+    const b = journalTokens(e);
+    if (!b.size) continue;
+    let inter = 0;
+    for (const w of a) if (b.has(w)) inter++;
+    if (inter / (a.size + b.size - inter) >= 0.75) return true;
+  }
+  return false;
+}
+
 // Apply a reviewer mutation. Only supplied fields change; journal entries
-// append (capped); state replaces (it represents "current truth").
+// append (capped + deduped); state replaces (it represents "current truth").
 function updatePack(dir, { description, tags, stance, procedure, state, journal, skill, kind, learned_on } = {}, origin = "user") {
   const pack = readPack(dir);
   if (!pack) throw new Error(`no pack: ${dir}`);
@@ -370,9 +397,14 @@ function updatePack(dir, { description, tags, stance, procedure, state, journal,
   if (typeof state === "string" && state.trim()) { pack.sections.State = state.trim(); applied.push("State"); }
   if (typeof journal === "string" && journal.trim()) {
     const entries = pack.sections.Journal.split("\n").filter((l) => l.trim());
-    entries.push(`- [${today()}] ${journal.trim().replace(/\n+/g, " ")}`);
-    pack.sections.Journal = entries.slice(-MAX_JOURNAL_ENTRIES).join("\n");
-    applied.push("Journal");
+    const line = journal.trim().replace(/\n+/g, " ");
+    if (isNearDupJournal(line, entries.slice(-5))) {
+      pack.journalDeduped = true;
+    } else {
+      entries.push(`- [${today()}] ${line}`);
+      pack.sections.Journal = entries.slice(-MAX_JOURNAL_ENTRIES).join("\n");
+      applied.push("Journal");
+    }
   }
   writePack(pack);
   if (applied.length) setProvenance(dir, applied, origin);
@@ -590,7 +622,7 @@ function matchPacks(text, { limit = 3, threshold = null } = {}) {
 
 module.exports = {
   PACKS_DIR, SECTIONS, slugify,
-  listPacks, findPack, readPack, writePack, createPack, updatePack, removePack,
+  listPacks, findPack, readPack, writePack, createPack, updatePack, removePack, isNearDupJournal,
   listSkillPacks, setSkill, listAbilities, setKind, parentByPrefix, setParent, recordApplied, recordCoUse,
   touchUsed, packNameFromPath, matchPacks, reindex, markIndexDirty,
   archivePack, restorePack, listArchived,

package/core/recall/discoverer.js

@@ -17,6 +17,7 @@
 
 const graph = require("./graph");
 const metrics = require("./metrics");
+const tuning = require("./tuning");
 const { spawnSubagent } = require("../subagent");
 const warmWalker = require("./warm-walker");
 const toolsLib = require("../tools");
@@ -26,12 +27,24 @@ const toolsLib = require("../tools");
 // entity-only). Optional — absent on old node where node:sqlite is missing.
 let toolGraph = null;
 try { toolGraph = require("../tool-graph"); } catch (e) { /* old node */ }
+// Episodic memory: FTS over past transcripts (same optionality as the graphs).
+let transcriptIndex = null;
+try { transcriptIndex = require("../transcript-index"); } catch (e) { /* old node */ }
 
 const WALKER_MODEL = process.env.RECALL_DISCOVERER_MODEL || "haiku";
 const WALKER_TIMEOUT_MS = Number(process.env.RECALL_DISCOVERER_TIMEOUT_MS || 25000);
 const WALKER_ENABLED = String(process.env.RECALL_DISCOVERER_WALKER || "on").toLowerCase() !== "off";
+// Sizing/tier knobs (walker candidate cap, episode limit, seeds-tier width,
+// cascade on/off) live in recall/tuning.js — dream-adjustable within hard
+// bounds, env pins still win. The walker candidate cap exists because uncapped,
+// a wordy turn seeds 15-40 nodes × 600-char excerpts and the walker prompt
+// measured as THE dominant recall latency (p50 ~13.5s even warm).
+const EPISODES_ENABLED = String(process.env.RECALL_EPISODES || "on").toLowerCase() !== "off";
 const EXCERPT_CHARS = 600;
 const CONTEXT_CLIP = 3000;
+// Fraction of cascade auto-verdicts also sent to the judge as an accuracy
+// audit — divergence is logged and the dream disables the cascade if it drifts.
+const SHADOW_RATE = Number(process.env.RECALL_CASCADE_SHADOW_RATE || 0.1);
 
 let _lastSync = 0;
 const SYNC_INTERVAL_MS = 60000;
@@ -45,16 +58,42 @@ function maybeSync(packsLib, entitiesLib) {
   try { graph.syncFromCorpus(packsLib, entitiesLib); } catch (e) {}
 }
 
-// Cheap pre-gate: terse acknowledgements / pure pleasantries don't need recall.
-function needsRecall(userText, seedCount) {
+// Tiered pre-gate. The old boolean gate returned true whenever FTS found ANY
+// seed — with a 147-pack corpus that is virtually every turn (measured: gated
+// 0.4% of 500 turns), so "thanks!" still paid a full 13s walk. Three tiers:
+//   skip  — pure pleasantry/ack/emoji: no recall at all, regardless of seeds.
+//   seeds — short command-like turns (≤4 words): keyword seeds are precise
+//           enough; inject user-origin seeds directly and skip graph + walker
+//           (the classic baseline, ~ms instead of ~13s).
+//   full  — substantive turns: graph expansion + walker judgement.
+const PLEASANTRY_RE = /^(ok(ay)?|k|kk|thanks?|thank you|thx|ty|yes|yep|yeah|no|nope|nah|cool|nice|great|perfect|awesome|lovely|done|sure|got it|sounds good|will do|lol|haha|hi|hey|hello|yo|morning|evening|night|good (morning|afternoon|evening|night)|bye|goodnight|cheers|please do|go ahead)\b/;
+
+function recallTier(userText, seedCount) {
   const t = String(userText || "").trim().toLowerCase();
-  if (!t) return false;
-  if (seedCount > 0) return true; // FTS already found something — never gate it out
-  // No seeds: only bother with graph/walker work for a substantive message.
+  if (!t) return "skip";
   const words = t.split(/\s+/).filter(Boolean);
-  if (words.length <= 2) return false;
-  if (/^(ok|okay|thanks|thank you|yes|yep|no|nope|cool|nice|great|done|sure|got it|k)\b/.test(t)) return false;
-  return true;
+  if (!/[a-z0-9]/.test(t)) return "skip"; // emoji/punctuation only
+  if (words.length <= 4 && PLEASANTRY_RE.test(t)) return "skip";
+  if (words.length <= 2 && seedCount === 0) return "skip";
+  if (words.length <= tuning.get("seedsTierMaxWords")) return "seeds";
+  return "full";
+}
+
+// Evidence-backed pre-verdict for one candidate, from its rolling usage stats.
+// Conservative by design: auto-drop needs a long never-kept/never-used streak;
+// auto-keep needs a high keep-rate AND at least one real use (open/reviewer).
+// Anything without strong history returns null and goes to the judge.
+function cascadeVerdict(st) {
+  if (!st) return null;
+  const seen = st.seen || 0, kept = st.kept || 0, used = (st.open || 0) + (st.rev || 0);
+  if (seen >= 6 && kept === 0 && used === 0) return "drop";
+  if (seen >= 5 && kept / seen >= 0.8 && used >= 1) return "keep";
+  return null;
+}
+
+// Back-compat boolean view of the tier (exported/tested API).
+function needsRecall(userText, seedCount) {
+  return recallTier(userText, seedCount) !== "skip";
 }
 
 function idFor(m) { return m.dir ? `pack:${m.dir}` : `entity:${m.slug}`; }
@@ -95,6 +134,7 @@ const WALKER_SYSTEM = [
   "Decide which nodes are GENUINELY relevant to what the user is doing now.",
   "Keep graph-linked nodes ONLY if they actually bear on the task (e.g. a shared theme/commit-style that governs the thing being worked on). Drop incidental keyword overlaps.",
   "Some candidates are reusable tools (id starts `tool:`). Keep a tool ONLY if running it would actually help with THIS task; drop tools merely related by keyword.",
+  "Some candidates are past-conversation episodes (id starts `episode:`). Keep one ONLY if that past exchange holds a decision, method, or outcome directly reusable for the current message — not mere topic overlap.",
   "For each kept node write a terse why (≤12 words). Quote concrete facts verbatim; never invent.",
   'Reply with ONLY a JSON array: [{"id":"pack:foo","why":"shared lime theme governs this app"}]. Use [] if none.',
 ].join("\n");
@@ -102,20 +142,25 @@ const WALKER_SYSTEM = [
 // Run the walker model on the prompt. Prefer the warm (reused) process for
 // low latency; on any warm-path error fall back to a cold spawn — identical
 // model/prompt/contract, so quality is unchanged and recall never silently
-// degrades to the classic engine.
+// degrades to the classic engine. Returns { text, costUsd, source }.
 async function runWalker(prompt) {
   const opts = { model: WALKER_MODEL, systemPrompt: WALKER_SYSTEM, timeoutMs: WALKER_TIMEOUT_MS };
   if (warmWalker.isEnabled()) {
     try {
-      return await warmWalker.walkWarm(prompt, opts);
+      const r = await warmWalker.walkWarm(prompt, opts);
+      return { text: r.text, costUsd: r.costUsd, source: "warm" };
     } catch (e) { /* fall back to cold spawn below */ }
   }
   const { text } = await spawnSubagent(prompt, opts);
-  return text;
+  return { text, costUsd: null, source: "cold" };
 }
 
+// Judge candidates. Returns { kept: Map|null, costUsd, source, walkerMs } —
+// kept null means fail-open (walker off/failed/unparseable).
 async function walk(userText, contextText, candidates) {
-  if (!WALKER_ENABLED || candidates.length === 0) return null;
+  if (!WALKER_ENABLED || candidates.length === 0) {
+    return { kept: null, costUsd: null, source: "off", walkerMs: 0 };
+  }
   const lines = candidates.map((c) => {
     const tag = c.activated ? ` [linked via ${c.via || "graph"}]` : "";
     return `- ${c.id}: ${c.name}${tag}${c.description ? `\n    ${c.description}` : ""}${c.excerpt ? `\n    excerpt: ${c.excerpt.replace(/\n/g, " ")}` : ""}`;
@@ -130,12 +175,14 @@ async function walk(userText, contextText, candidates) {
     "",
     'Reply ONLY with the JSON array of kept nodes and their why, e.g. [{"id":"' + candidates[0].id + '","why":"..."}].',
   ].join("\n");
+  const t0 = Date.now();
   try {
-    const text = await runWalker(prompt);
+    const { text, costUsd, source } = await runWalker(prompt);
+    const walkerMs = Date.now() - t0;
     const match = String(text || "").match(/\[[\s\S]*\]/);
-    if (!match) return null;
+    if (!match) return { kept: null, costUsd, source, walkerMs };
     const arr = JSON.parse(match[0]);
-    if (!Array.isArray(arr)) return null;
+    if (!Array.isArray(arr)) return { kept: null, costUsd, source, walkerMs };
     const known = new Set(candidates.map((c) => c.id));
     const out = new Map();
     for (const item of arr) {
@@ -143,9 +190,9 @@ async function walk(userText, contextText, candidates) {
         out.set(item.id, String(item.why || "").slice(0, 120));
       }
     }
-    return out;
+    return { kept: out, costUsd, source, walkerMs };
   } catch (e) {
-    return null;
+    return { kept: null, costUsd: null, source: "failed", walkerMs: Date.now() - t0 };
   }
 }
 
@@ -154,8 +201,6 @@ async function run(ctx) {
   const { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEntityBlock } = helpers;
   const started = Date.now();
 
-  maybeSync(packsLib, entitiesLib);
-
   // 1+2: seed via FTS (user words + context), same as classic.
   let packSeeds = [];
   let entSeeds = [];
@@ -185,32 +230,55 @@ async function run(ctx) {
   } catch (e) {}
 
   const seedCount = packSeeds.length + entSeeds.length + toolSeedByName.size;
+  const seedMs = Date.now() - started;
 
-  // 1: pre-gate.
-  if (!needsRecall(userText, seedCount)) {
-    metrics.logTurn({ engine: "discoverer", query: userText, gated: true, latencyMs: Date.now() - started });
-    return { packBlock: "", entityBlock: "", toolBlock: "", packMatches: [], entityMatches: [], toolMatches: [], why: {}, gated: true };
+  // 1: tiered pre-gate.
+  const tier = recallTier(userText, seedCount);
+  if (tier === "skip") {
+    metrics.logTurn({ engine: "discoverer", model: WALKER_MODEL, query: userText, gated: true, tier, latencyMs: Date.now() - started });
+    return { packBlock: "", entityBlock: "", toolBlock: "", episodeBlock: "", packMatches: [], entityMatches: [], toolMatches: [], episodeMatches: [], why: {}, gated: true, tier };
   }
 
-  // 3: spreading activation from seeds across the graph.
+  // 3: spreading activation from seeds across the graph (full tier only — the
+  // seeds tier injects keyword seeds directly, no graph, no walker).
   const seedNodes = [
     ...packSeeds.map((m) => ({ id: `pack:${m.dir}`, score: m.score || 2 })),
     ...entSeeds.map((m) => ({ id: `entity:${m.slug}`, score: m.score || 2 })),
   ];
   const seedIds = new Set(seedNodes.map((s) => s.id));
   let activated = new Map();
-  try { activated = graph.expand(seedNodes, {}); } catch (e) {}
+  const expandStarted = Date.now();
+  if (tier === "full") {
+    maybeSync(packsLib, entitiesLib);
+    try { activated = graph.expand(seedNodes, {}); } catch (e) {}
+  }
+  const expandMs = Date.now() - expandStarted;
 
-  // 4: assemble candidates (seeds + activated), build excerpts, run the walker.
-  const candIds = new Set(seedIds);
-  for (const id of activated.keys()) candIds.add(id);
+  // 4: assemble candidates (seeds + activated) in priority order — user seeds
+  // by score, then context seeds, then graph-activated by activation — capped
+  // at MAX_WALKER_CANDIDATES so the walker prompt stays small and fast. Only
+  // the full tier pays for excerpts; the seeds tier never reads them.
+  const seedRank = new Map();
+  for (const m of packSeeds) seedRank.set(`pack:${m.dir}`, { score: m.score || 2, origin: m.origin });
+  for (const m of entSeeds) seedRank.set(`entity:${m.slug}`, { score: m.score || 2, origin: m.origin });
+  const orderedIds = [...seedIds].sort((a, b) => {
+    const ra = seedRank.get(a) || {}, rb = seedRank.get(b) || {};
+    const ua = ra.origin === "user" ? 0 : 1, ub = rb.origin === "user" ? 0 : 1;
+    return ua - ub || (rb.score || 0) - (ra.score || 0);
+  });
+  for (const [id] of [...activated.entries()].sort((x, y) => (y[1].activation || 0) - (x[1].activation || 0))) {
+    if (!seedIds.has(id)) orderedIds.push(id);
+  }
   const candidates = [];
-  for (const id of candIds) {
-    const base = excerptFor(id, packsLib, entitiesLib);
-    if (!base) continue;
-    const act = activated.get(id);
-    candidates.push({ ...base, activated: !seedIds.has(id), via: act ? act.via : null });
+  if (tier === "full") {
+    for (const id of orderedIds.slice(0, tuning.get("walkerMaxCandidates"))) {
+      const base = excerptFor(id, packsLib, entitiesLib);
+      if (!base) continue;
+      const act = activated.get(id);
+      candidates.push({ ...base, activated: !seedIds.has(id), via: act ? act.via : null });
+    }
   }
+  const candIds = new Set(tier === "full" ? candidates.map((c) => c.id) : seedIds);
 
   // Tool candidates = direct tool seeds + tools that belong to any candidate
   // pack (declared via the tool's `pack:` header, or used-in-topic per the
@@ -221,7 +289,7 @@ async function run(ctx) {
   for (const id of candIds) if (id.startsWith("pack:")) candPackDirs.add(id.slice(5));
   const toolCand = new Map();
   for (const [name, t] of toolSeedByName) toolCand.set(name, { name, description: t.description, via: null });
-  if (candPackDirs.size) {
+  if (tier === "full" && candPackDirs.size) {
     try {
       const byPack = new Map();
       for (const t of toolsLib.listTools()) {
@@ -247,19 +315,95 @@ async function run(ctx) {
       } catch (e) {}
     }
   }
-  for (const c of toolCand.values()) {
-    const base = excerptFor(`tool:${c.name}`, packsLib, entitiesLib);
-    if (!base) continue;
-    candidates.push({ ...base, activated: !!c.via, via: c.via });
+  if (tier === "full") {
+    for (const c of toolCand.values()) {
+      const base = excerptFor(`tool:${c.name}`, packsLib, entitiesLib);
+      if (!base) continue;
+      candidates.push({ ...base, activated: !!c.via, via: c.via });
+    }
+  }
+
+  // Episodic hop: FTS over past transcripts turns up prior sessions on this
+  // topic; the walker judges them like any node. This is the bridge from
+  // knowledge (packs) to episodes (what we actually did last time) — kept ones
+  // inject as a snippet plus a pointer to reopen the conversation window.
+  let episodeCands = [];
+  if (tier === "full" && EPISODES_ENABLED && transcriptIndex && transcriptIndex.available()) {
+    try {
+      const { hits } = transcriptIndex.search(userText, { limit: tuning.get("episodeLimit") });
+      episodeCands = (hits || []).map((h) => {
+        const terms = [...String(h.snip || "").matchAll(/>>(.+?)<</g)].map((m) => m[1]).slice(0, 4);
+        return {
+          id: `episode:${require("path").basename(String(h.file || ""), ".jsonl")}:${h.line}`,
+          name: `Past conversation${h.project ? ` (${h.project})` : ""}${h.ts ? ` ${String(h.ts).slice(0, 10)}` : ""}`,
+          description: "",
+          excerpt: clip(String(h.snip || "").replace(/>>|<</g, ""), EXCERPT_CHARS),
+          activated: true,
+          via: "transcript",
+          _terms: terms,
+        };
+      });
+      candidates.push(...episodeCands);
+    } catch (e) { /* episodic recall is best-effort */ }
+  }
+
+  // Walker cascade: candidates with strong usage history get an evidence-backed
+  // auto-verdict and skip the judge — the model reads only the ambiguous middle
+  // (fewer tokens, less noise in the prompt). A random SHADOW_RATE slice of
+  // auto-decided candidates is judged anyway and compared, so the shortcut is
+  // continuously audited against the model it replaces; on shadowed candidates
+  // the judge's verdict wins. Top-3 ranked candidates and episodes (no stable
+  // history) always go to the judge.
+  const cascadeOn = tier === "full" && tuning.get("cascade") !== "off";
+  const autoKept = new Map(); // id -> canned why (honest provenance)
+  const autoDropped = [];
+  const shadowVerdicts = new Map(); // id -> auto verdict, also sent to judge
+  let judgeCands = candidates;
+  if (cascadeOn && candidates.length) {
+    let nodeHist = {};
+    try { nodeHist = metrics.nodeStats().nodes || {}; } catch (e) {}
+    const protectedIds = new Set(orderedIds.slice(0, 3));
+    judgeCands = [];
+    for (const c of candidates) {
+      const st = c.id.startsWith("episode:") || protectedIds.has(c.id) ? null : nodeHist[c.id];
+      const v = cascadeVerdict(st);
+      if (!v) { judgeCands.push(c); continue; }
+      if (Math.random() < SHADOW_RATE) { shadowVerdicts.set(c.id, v); judgeCands.push(c); continue; }
+      if (v === "keep") autoKept.set(c.id, `kept ${st.kept}/${st.seen} recent similar turns`);
+      else autoDropped.push(c.id);
+    }
   }
 
-  const whyById = (await walk(userText, contextText || fullContext, candidates)) || null;
+  const walkRes = await walk(userText, contextText || fullContext, judgeCands);
+  const whyById = walkRes.kept;
 
-  // Decide the kept set. Walker result wins; on fail-open keep the user-origin
-  // seeds only (classic baseline) and drop graph-expanded/context guesses.
+  let shadowChecks = 0, shadowAgree = 0;
+  if (whyById && shadowVerdicts.size) {
+    for (const [id, v] of shadowVerdicts) {
+      const agree = (v === "keep") === whyById.has(id);
+      shadowChecks++;
+      if (agree) shadowAgree++;
+      metrics.logShadow(agree);
+    }
+  }
+
+  // Decide the kept set. Walker result + evidence auto-keeps win; on walker
+  // fail-open (full tier) keep the strongest 3 user-origin seeds only — an
+  // unjudged tool or episode is a guess, not a memory (measured: a failed walk
+  // once kept 15 unjudged seeds including WiFi tools for a dream question). The
+  // seeds tier keeps its classic contract: all user-origin keyword seeds.
+  let whyMap = whyById ? new Map(whyById) : null;
+  if (whyMap) for (const [id, why] of autoKept) whyMap.set(id, why);
   let keptIds;
-  if (whyById) {
-    keptIds = new Set(whyById.keys());
+  if (whyMap) {
+    keptIds = new Set(whyMap.keys());
+  } else if (tier === "full") {
+    const rankedUserSeeds = [
+      ...packSeeds.filter((m) => m.origin === "user").map((m) => ({ id: `pack:${m.dir}`, score: m.score || 2 })),
+      ...entSeeds.filter((m) => m.origin === "user").map((m) => ({ id: `entity:${m.slug}`, score: m.score || 2 })),
+    ].sort((a, b) => b.score - a.score).slice(0, 3).map((s) => s.id);
+    keptIds = new Set([...autoKept.keys(), ...rankedUserSeeds]);
+    if (autoKept.size) whyMap = new Map(autoKept);
   } else {
     keptIds = new Set(
       [...packSeeds.filter((m) => m.origin === "user").map((m) => `pack:${m.dir}`),
@@ -293,9 +437,9 @@ async function run(ctx) {
   // 5: render via shared builders, then weave in the why-bullets.
   let packBlock = buildPackBlock(finalPacks, budget);
   const entityBlock = buildEntityBlock(finalEnts, budget);
-  if (packBlock && whyById) {
+  if (packBlock && whyMap) {
     const bullets = finalPacks
-      .map((m) => ({ m, why: whyById.get(`pack:${m.dir}`) }))
+      .map((m) => ({ m, why: whyMap.get(`pack:${m.dir}`) }))
       .filter((x) => x.why)
       .map((x) => `- ${x.m.name || x.m.dir}: ${x.why}`);
     if (bullets.length) packBlock = `\n\n### Why these surfaced (discoverer)\n${bullets.join("\n")}${packBlock}`;
@@ -307,7 +451,7 @@ async function run(ctx) {
   const toolMatches = [];
   for (const c of toolCand.values()) {
     if (keptIds.has(`tool:${c.name}`)) {
-      toolMatches.push({ name: c.name, description: c.description, why: whyById ? whyById.get(`tool:${c.name}`) || "" : "" });
+      toolMatches.push({ name: c.name, description: c.description, why: whyMap ? whyMap.get(`tool:${c.name}`) || "" : "" });
     }
   }
   let toolBlock = "";
@@ -320,20 +464,45 @@ async function run(ctx) {
     toolBlock = `\n\n## Tools that may help here\nSurfaced for this turn — run with \`open-claudia tool run <name> [args]\`; read docs/source with \`open-claudia tool show <name>\`:\n${lines.join("\n")}\n`;
   }
 
+  // Past-conversation episodes the walker kept (fail-open drops them — an
+  // unjudged transcript snippet is a guess, not a memory).
+  const episodeMatches = episodeCands
+    .filter((c) => keptIds.has(c.id))
+    .map((c) => ({ id: c.id, name: c.name, excerpt: c.excerpt, terms: c._terms, why: whyMap ? whyMap.get(c.id) || "" : "" }));
+  let episodeBlock = "";
+  if (episodeMatches.length) {
+    const lines = episodeMatches.map((m) => {
+      const q = (m.terms && m.terms.length ? m.terms.join(" ") : String(m.excerpt).split(/\s+/).slice(0, 4).join(" ")).replace(/"/g, "");
+      return `- ${m.name}: "${m.excerpt}"${m.why ? ` — ${m.why}` : ""}\n  ↳ full context: open-claudia transcript-search "${q}" --all`;
+    });
+    episodeBlock = `\n\n## Past work that looks related\nFrom earlier conversations — verify before relying on it:\n${lines.join("\n")}\n`;
+  }
+
   metrics.logTurn({
     engine: "discoverer",
+    model: WALKER_MODEL,
     query: userText,
+    tier,
     seeds: seedNodes,
     activated: [...activated.entries()].map(([id, a]) => ({ id, activation: a.activation, hop: a.hop })),
-    kept: [...keptIds].map((id) => ({ id, why: whyById ? whyById.get(id) : "" })),
+    cand: candidates.map((c) => ({ id: c.id, act: !!c.activated })),
+    kept: [...keptIds].map((id) => ({ id, why: whyMap ? whyMap.get(id) : "" })),
+    auto: (autoKept.size || autoDropped.length || shadowChecks)
+      ? { kept: [...autoKept.keys()], dropped: autoDropped, shadow: { checks: shadowChecks, agree: shadowAgree } }
+      : null,
     gated: false,
     latencyMs: Date.now() - started,
+    seedMs,
+    expandMs,
+    walkerMs: walkRes.walkerMs,
+    walker: walkRes.source,
+    costUsd: walkRes.costUsd || 0,
   });
 
   return {
-    packBlock, entityBlock, toolBlock, packMatches: finalPacks, entityMatches: finalEnts,
-    toolMatches, why: whyById ? Object.fromEntries(whyById) : {}, gated: false,
+    packBlock, entityBlock, toolBlock, episodeBlock, packMatches: finalPacks, entityMatches: finalEnts,
+    toolMatches, episodeMatches, why: whyMap ? Object.fromEntries(whyMap) : {}, gated: false, tier,
   };
 }
 
-module.exports = { name: "discoverer", run, needsRecall, walk };
+module.exports = { name: "discoverer", run, needsRecall, recallTier, walk, cascadeVerdict };

package/core/recall/graph.js

@@ -156,6 +156,33 @@ function reinforceSet(nodeIds, amount = 1) {
   }
 }
 
+// Negative Hebbian: weaken every edge touching a node that keeps surfacing
+// via the graph but never gets kept or used — firing wrongly, so unwire.
+// Same floor contract as decay(); additionally, `related` edges that fall to
+// their structural base are deleted outright: a link-derived edge re-derives
+// at base weight on the next sync (harmless), while a co-use edge that earned
+// its weight from wrong firings is gone for good.
+function weakenNode(nodeId, { factor = 0.6, prune = true } = {}) {
+  const db = openDb();
+  if (!db || !nodeId) return { weakened: 0, pruned: 0 };
+  let weakened = 0, pruned = 0;
+  try {
+    const rows = db.prepare("SELECT src, dst, type, weight FROM edges WHERE src=? OR dst=?").all(nodeId, nodeId);
+    for (const e of rows) {
+      const floor = BASE_WEIGHT[e.type] || 0;
+      const next = Math.max(floor, e.weight * factor);
+      if (prune && e.type === "related" && next <= floor + 0.05) {
+        db.prepare("DELETE FROM edges WHERE src=? AND dst=? AND type=?").run(e.src, e.dst, e.type);
+        pruned++;
+      } else if (Math.abs(next - e.weight) > 1e-6) {
+        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, e.src, e.dst, e.type);
+        weakened++;
+      }
+    }
+  } catch (e) {}
+  return { weakened, pruned };
+}
+
 // 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 } = {}) {
@@ -377,7 +404,7 @@ module.exports = {
   EDGE_TYPES, DEFAULTS, GRAPH_DB,
   available, openDb,
   addEdge, removeEdge, allEdges, neighbors,
-  reinforce, reinforceSet, decay, expand,
-  syncFromCorpus, parseLinks, pruneOrphans, tend, stats,
+  reinforce, reinforceSet, decay, weakenNode, expand,
+  syncFromCorpus, parseLinks, pruneOrphans, tend, stats, isSharedConcern,
   _resetForTest,
 };