@inetafrica/open-claudia 2.6.58 → 2.6.59

package/core/dream.js

@@ -23,6 +23,9 @@ const daySeeds = require("./day-seeds");
 const packGuard = require("./pack-guard");
 const persona = require("./persona");
 const { spawnSubagent } = require("./subagent");
+const recallMetrics = require("./recall/metrics");
+const recallTuning = require("./recall/tuning");
+const recallGraphLib = require("./recall/graph");
 
 // Graph surgery + threshold tuning is the highest-judgment work in the recall
 // system, so the dream runs on the best available high tier. Honour an explicit
@@ -107,11 +110,134 @@ function clip(s, n) {
   return t.length > n ? t.slice(0, n) + "\n…[truncated]" : t;
 }
 
-function buildDreamPrompt() {
+// --- Dream state: last run / last full sweep / metrics snapshot for windowed
+// health deltas / pending knob-change awaiting its rollback check.
+const DREAM_STATE_FILE = path.join(CONFIG_DIR, "dream-state.json");
+const FULL_SWEEP_DAYS = Number(process.env.DREAM_FULL_SWEEP_DAYS || 30);
+
+function readDreamState() {
+  try { return JSON.parse(fs.readFileSync(DREAM_STATE_FILE, "utf8")) || {}; } catch (e) { return {}; }
+}
+function writeDreamState(s) {
+  try { fs.writeFileSync(DREAM_STATE_FILE, JSON.stringify(s, null, 2)); } catch (e) {}
+}
+
+// Windowed metric deltas between two summary snapshots (counters only grow).
+const DELTA_KEYS = ["turns", "gatedTurns", "seedsOnlyTurns", "seedsTotal", "activatedTotal", "keptTotal",
+  "rescueTurns", "rescues", "opens", "reviewerUses", "reviewerSkipped", "autoKept", "autoDropped",
+  "shadowChecks", "shadowAgree", "latencyMsTotal", "costUsd"];
+function summaryDelta(cur, prev) {
+  const c = cur || {}, p = prev || {};
+  const d = {};
+  for (const k of DELTA_KEYS) d[k] = Math.max(0, (c[k] || 0) - (p[k] || 0));
+  d.byTier = {};
+  for (const [t, v] of Object.entries(c.byTier || {})) {
+    const pv = (p.byTier || {})[t] || { n: 0, ms: 0 };
+    d.byTier[t] = { n: Math.max(0, (v.n || 0) - pv.n), ms: Math.max(0, (v.ms || 0) - pv.ms) };
+  }
+  return d;
+}
+function healthOf(delta) {
+  const turns = delta.turns || 0;
+  const used = (delta.opens || 0) + (delta.reviewerUses || 0);
+  return {
+    turns,
+    rescueRate: turns ? (delta.rescueTurns || 0) / turns : 0,
+    noiseRate: delta.keptTotal ? Math.max(0, 1 - used / delta.keptTotal) : 0,
+    avgLatencyMs: turns ? Math.round((delta.latencyMsTotal || 0) / turns) : 0,
+  };
+}
+
+// --- Algorithmic pre-computation for the consolidation prompt. Instead of
+// asking the model to discover duplicates in a wall of ~130 full pack bodies,
+// deterministic code picks (a) which packs deserve a full dump this night and
+// (b) which look like merge candidates — the model judges pre-computed
+// clusters, everything else rides along as a one-line evidence row. Cuts the
+// nightly prompt by ~70% with no accuracy loss: an untouched pack was already
+// judged by a previous dream, and merge candidates are chosen by content
+// similarity over the WHOLE corpus regardless of touch date.
+function dreamTokens(s) {
+  return new Set(String(s || "").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2));
+}
+function packSim(a, b) {
+  const ta = dreamTokens(`${a.name} ${a.description} ${a.tags.join(" ")}`);
+  const tb = dreamTokens(`${b.name} ${b.description} ${b.tags.join(" ")}`);
+  if (!ta.size || !tb.size) return 0;
+  let inter = 0;
+  for (const w of ta) if (tb.has(w)) inter++;
+  return inter / (ta.size + tb.size - inter);
+}
+function mergeClusters(allPacks, { threshold = 0.5, maxClusters = 6, maxMembers = 4 } = {}) {
+  const parent = new Map(allPacks.map((p) => [p.dir, p.dir]));
+  const find = (x) => { while (parent.get(x) !== x) { parent.set(x, parent.get(parent.get(x))); x = parent.get(x); } return x; };
+  const union = (a, b) => { const ra = find(a), rb = find(b); if (ra !== rb) parent.set(ra, rb); };
+  for (let i = 0; i < allPacks.length; i++) {
+    for (let j = i + 1; j < allPacks.length; j++) {
+      const a = allPacks[i], b = allPacks[j];
+      if ((a.kind === "ability") !== (b.kind === "ability")) continue; // ability/context never merge
+      if (packSim(a, b) >= threshold) union(a.dir, b.dir);
+    }
+  }
+  const groups = new Map();
+  for (const p of allPacks) {
+    const r = find(p.dir);
+    if (!groups.has(r)) groups.set(r, []);
+    groups.get(r).push(p.dir);
+  }
+  return [...groups.values()]
+    .filter((g) => g.length >= 2)
+    .map((g) => g.slice(0, maxMembers))
+    .slice(0, maxClusters);
+}
+
+// Which packs get their FULL body in tonight's prompt: touched since the last
+// dream, their 1-hop graph neighbours, every shared-concern pack (few, and
+// they govern), and all merge-cluster members. On a full sweep: everything.
+function selectDumpDirs(allPacks, { sinceTs, fullSweep, clusters }) {
+  if (fullSweep || !sinceTs) return new Set(allPacks.map((p) => p.dir));
+  const dump = new Set();
+  for (const p of allPacks) {
+    if ((p.updated && p.updated > sinceTs) || (p.last_used && p.last_used > sinceTs)) dump.add(p.dir);
+    if (recallGraphLib.isSharedConcern(p)) dump.add(p.dir);
+  }
+  try {
+    if (recallGraphLib.available()) {
+      for (const dir of [...dump]) {
+        for (const nb of recallGraphLib.neighbors(`pack:${dir}`)) {
+          if (nb.node.startsWith("pack:")) dump.add(nb.node.slice(5));
+        }
+      }
+    }
+  } catch (e) {}
+  for (const g of clusters || []) for (const dir of g) dump.add(dir);
+  return dump;
+}
+
+function evidenceLines(ev) {
+  if (!ev || !ev.summary || !(ev.summary.turns > 0)) return "(no recall telemetry yet)";
+  const out = [];
+  if (ev.neverKept.length) {
+    out.push("Surfaced repeatedly but NEVER kept or used (recall noise — prime retag/archive candidates):");
+    for (const n of ev.neverKept.slice(0, 12)) out.push(`- ${n.id} (surfaced ${n.seen}×${n.act ? `, ${n.act}× via graph` : ""})`);
+  }
+  if (ev.topRescued.length) {
+    out.push("Frequently RESCUED by the graph (keyword match misses them — their name/description/tags don't match how they're asked about; retag these):");
+    for (const n of ev.topRescued.slice(0, 8)) out.push(`- ${n.id} (rescued ${n.rescues}×)`);
+  }
+  return out.join("\n") || "(no strong signals yet)";
+}
+
+function buildDreamPrompt({ sinceTs = null, fullSweep = true, clusters = [], evidence = null, windowDelta = null } = {}) {
   const allPacks = packs.listPacks();
   const allEntities = entities.listEntities();
 
-  const packDump = allPacks.map((p) => clip([
+  const dumpDirs = selectDumpDirs(allPacks, { sinceTs, fullSweep, clusters });
+  const nodeHist = (() => { try { return recallMetrics.nodeStats().nodes || {}; } catch (e) { return {}; } })();
+
+  const fullPacks = allPacks.filter((p) => dumpDirs.has(p.dir));
+  const rowPacks = allPacks.filter((p) => !dumpDirs.has(p.dir));
+
+  const packDump = fullPacks.map((p) => clip([
     `=== pack: ${p.dir}${p.parent ? ` (parent: ${p.parent})` : ""}${p.kind === "ability" ? " [ABILITY]" : ""}`,
     `name: ${p.name}`,
     `description: ${p.description}`,
@@ -123,6 +249,24 @@ function buildDreamPrompt() {
     `Journal:\n${p.sections.Journal}`,
   ].join("\n"), MAX_PACK_CHARS)).join("\n\n") || "(none)";
 
+  // One evidence row per untouched pack — enough for retag/parents/archive
+  // judgement (name, tags, usage, recall stats) without the body cost.
+  const packIndex = rowPacks.map((p) => {
+    const h = nodeHist[`pack:${p.dir}`] || {};
+    const idleDays = p.last_used ? Math.round((Date.now() - Date.parse(p.last_used)) / 86400000) : null;
+    return `- ${p.dir}${p.kind === "ability" ? " [ABILITY]" : ""}${p.parent ? ` (parent: ${p.parent})` : ""} | ${p.name} | tags: ${p.tags.join(", ") || "—"} | used ${p.usage_count || 0}×${idleDays !== null ? `, idle ${idleDays}d` : ", never used"} | recall: surfaced ${h.seen || 0}× kept ${h.kept || 0}×`;
+  }).join("\n");
+
+  const clusterBlock = (clusters || []).length
+    ? clusters.map((g, i) => `${i + 1}. ${g.join(" + ")}`).join("\n")
+    : "(none found)";
+
+  const win = windowDelta ? healthOf(windowDelta) : null;
+  const evidenceBlock = [
+    win ? `Window since last dream: ${win.turns} turns, rescue rate ${(win.rescueRate * 100).toFixed(0)}% (kept nodes no keyword seed found — the graph saved them), noise ${(win.noiseRate * 100).toFixed(0)}% (kept but never opened/used), avg recall latency ${win.avgLatencyMs}ms.` : "",
+    evidenceLines(evidence),
+  ].filter(Boolean).join("\n");
+
   const entityDump = allEntities.map((e) => clip([
     `=== entity: ${e.slug} (${e.type}${e.aliases.length ? `, aka ${e.aliases.join(", ")}` : ""})`,
     `description: ${e.description}`,
@@ -135,13 +279,27 @@ function buildDreamPrompt() {
     `- [${l.id}] "${l.text}"${l.src ? ` (src: ${l.src})` : ""} — reinforced ${l.reinforced || 0}×, since ${(l.created || "").slice(0, 10)}, origin ${l.origin || "user"}`
   ).join("\n") || "(none)";
 
-  return `You are the dream pass of a personal AI assistant called Open Claudia — the overnight consolidation of her long-term memory. Below is her entire memory: context packs (living topic documents), entity notes (people/places/projects/orgs/systems), and her always-loaded lessons, plus her current persona.
+  const knobBlock = recallTuning.knobTable().map((k) =>
+    `- ${k.name}: current ${k.current}${k.values ? ` (one of ${k.values.join("/")})` : ` (bounds ${k.min}–${k.max}, default ${k.default})`}${k.pinned ? " [PINNED]" : ""}`
+  ).join("\n");
 
-Today: ${new Date().toISOString().slice(0, 10)}
+  return `You are the dream pass of a personal AI assistant called Open Claudia — the overnight consolidation of her long-term memory. Below is her memory: context packs (living topic documents), entity notes (people/places/projects/orgs/systems), and her always-loaded lessons, plus her current persona.
+
+Today: ${new Date().toISOString().slice(0, 10)}${fullSweep ? " (FULL SWEEP — every pack shown in full)" : ` (delta night — packs touched since ${String(sinceTs).slice(0, 10)}, their graph neighbours, shared concerns, and merge candidates are shown in full; the rest as index rows)`}
 
-CONTEXT PACKS:
+Some packs are SHARED CONCERNS (tagged concern/shared/cross-cutting): standing cross-cutting rules — change control, credential handling, release hygiene — that govern many projects via [[links]] and governed-by graph edges. They are rarely opened directly, so LOW USAGE ON A CONCERN IS NORMAL: never archive one for coldness, and never merge one into a project pack (or vice versa) — that would silently detach every governed project.
+
+CONTEXT PACKS (full):
 
 ${packDump}
+${packIndex ? `\nCONTEXT PACK INDEX (untouched since last dream — summaries only; valid targets for retag/parents/archive, but merges ONLY among the fully-shown packs above):\n\n${packIndex}\n` : ""}
+MERGE CANDIDATES (pre-computed by content similarity — judge these; do not hunt for others):
+
+${clusterBlock}
+
+RECALL EVIDENCE (live usage telemetry — ground consolidation decisions in these numbers):
+
+${evidenceBlock}
 
 ENTITIES:
 
@@ -167,6 +325,9 @@ Your job — decide what consolidation, if any, is warranted:
 8. lessons: keep the always-loaded lessons few and sharp — they cost context on EVERY turn. dedupe near-identical lessons (op "remove" the weaker, keep the better wording; or op "edit" to merge two into one tight line); tighten a clumsy lesson with op "edit". If the count exceeds the cap of ${lessons.MAX_LESSONS}, demote the weakest down to the cap — prefer lessons that are low-reinforced AND whose fact is safely captured in the pack named in their (src) (they will still surface by topic-match), and NEVER remove a frequently-reinforced lesson (those are actively preventing a repeat mistake). Even under the cap you may remove a lesson clearly redundant with its source pack that has stayed at 0 reinforcements for a long time, but be conservative — when in doubt, keep it. Reference lessons by their exact current text.
 9. persona: evolve the persona GENTLY — keep its structure and length (under 2200 chars), adjust only what recent work justifies (a new habit, a sharpened quirk). Most dreams should return null here.
 10. report: a short chat message to the owner, written AS Open Claudia in first person — warm, a little playful, a few emojis, mobile-friendly (2-6 short lines). Say what you tidied and why it helps. If you changed nothing, say the memory is in good shape, charmingly.
+11. tuning: OPTIONALLY propose ONE bounded recall-knob change, justified ONLY by the RECALL EVIDENCE numbers (e.g. rescue rate persistently low → raise walkerMaxCandidates; latency high while rescue is flat → lower it; seeds tier missing context on short asks → raise seedsTierMaxWords). Knobs and bounds:
+${knobBlock}
+A knob marked PINNED is operator-controlled — never propose it. Most nights the right answer is null: change nothing without clear evidence, never more than one knob, and prefer small steps (the system auto-rolls-back a change that worsens rescue/noise).
 
 Hard rules:
 - Never invent packs/entities not listed above; reference them by exact dir/slug.
@@ -184,7 +345,9 @@ Reply with ONLY a JSON object, no prose, no code fences:
  "archive": [{"pack": "<dir>", "reason": "<one line: why it's cold>"}],
  "lessons": [{"op": "remove", "text": "<exact current lesson text>", "reason": "<duplicate of … / safely in pack … / cold>"}],
  "persona": null,
+ "tuning": null,
  "report": "<chat message>"}
+(a tuning proposal looks like {"knob": "<name>", "to": <value>, "reason": "<one line grounded in the evidence>"})
 (a lesson "edit" looks like {"op": "edit", "text": "<exact current lesson text>", "to": "<tightened wording>"})`;
 }
 
@@ -206,6 +369,7 @@ function parseDream(text) {
       archive: arr("archive"),
       lessons: arr("lessons"),
       persona: typeof obj.persona === "string" ? obj.persona : null,
+      tuning: obj.tuning && typeof obj.tuning === "object" && obj.tuning.knob ? obj.tuning : null,
       report: typeof obj.report === "string" ? obj.report.trim() : "",
     };
   } catch (e) {
@@ -300,6 +464,14 @@ function applyDream(decision, backupRoot) {
         lines.push(`🧩 Skipped merge into ${m.into} — won't mix a reusable ability with project packs.`);
         continue;
       }
+      // Shared concerns govern many projects via edges; merging one into a
+      // project pack (or vice versa) would silently detach every governed
+      // project. Concern↔concern merges remain legal.
+      const intoIsConcern = recallGraphLib.isSharedConcern(into);
+      if (from.some((d) => recallGraphLib.isSharedConcern(packs.readPack(d)) !== intoIsConcern)) {
+        lines.push(`🛡️ Skipped merge into ${m.into} — won't mix a shared concern with a project pack.`);
+        continue;
+      }
       const mGuard = packGuard.scanSections({ stance: m.stance, procedure: m.procedure, state: m.state, journal: m.journal });
       if (mGuard.flagged) {
         console.warn(`[dream] guard blocked merge into ${m.into} (${mGuard.kind} in ${mGuard.section})`);
@@ -425,6 +597,10 @@ function applyDream(decision, backupRoot) {
         const pack = packs.readPack(dir);
         if (!pack) continue;
         if (allPacks.some((p) => p.parent === dir)) continue; // never orphan children
+        if (recallGraphLib.isSharedConcern(pack)) {
+          lines.push(`🛡️ Left ${dir} alone — shared concerns are rarely opened directly; coldness there is normal.`);
+          continue;
+        }
         const ageDays = pack.created ? (Date.now() - Date.parse(pack.created)) / 86400000 : Infinity;
         const idleDays = pack.last_used ? (Date.now() - Date.parse(pack.last_used)) / 86400000 : ageDays;
         const uses = Number(pack.usage_count) || 0;
@@ -680,7 +856,9 @@ function writeDreamReport(data) {
     if (data.introspection.proposed) {
       sec.push("", "### Proposed (not applied — DREAM_SELF_APPLY=off)", "```json", JSON.stringify(data.introspection.proposed, null, 2), "```");
     }
+    if (data.healthNote) sec.push("", "## Memory health", data.healthNote);
     if (data.graphNote) sec.push("", data.graphNote);
+    if (data.episodicNote) sec.push("", data.episodicNote);
     if (data.toolNote) sec.push("", data.toolNote);
     if (data.staleNote) sec.push("", data.staleNote);
     if (data.backupRoot) sec.push("", `Backups: ${data.backupRoot}`);
@@ -738,6 +916,72 @@ function nestPrefixFamilies(backupRoot) {
   return { lines, filed };
 }
 
+// Journal backfill dedupe. The runtime guard (packs.isNearDupJournal) stops
+// NEW near-duplicate journal lines, but entries stacked before it shipped are
+// still crowding real history out of capped Journals. Same similarity test,
+// applied retroactively: walk each Journal oldest→newest keeping a line only
+// if it isn't a near-dup of the last 5 kept. Backed up, capped per night.
+function journalBackfillDedupe(backupRoot, { maxPacks = 12 } = {}) {
+  const lines = [];
+  let cleaned = 0, removed = 0;
+  for (const meta of packs.listPacks()) {
+    if (cleaned >= maxPacks) break;
+    try {
+      const pack = packs.readPack(meta.dir);
+      const entries = (pack?.sections?.Journal || "").split("\n").filter((l) => l.trim());
+      if (entries.length < 3) continue;
+      const keep = [];
+      for (const e of entries) {
+        if (packs.isNearDupJournal(e, keep.slice(-5))) continue;
+        keep.push(e);
+      }
+      if (keep.length === entries.length) continue;
+      if (backupRoot) backupPack(meta.dir, backupRoot);
+      pack.sections.Journal = keep.join("\n");
+      pack.updated = new Date().toISOString();
+      packs.writePack(pack);
+      cleaned++;
+      removed += entries.length - keep.length;
+    } catch (e) { console.warn(`[dream] journal dedupe failed for ${meta.dir}: ${e.message}`); }
+  }
+  if (removed) lines.push(`🧽 Collapsed ${removed} near-duplicate journal line${removed === 1 ? "" : "s"} across ${cleaned} pack${cleaned === 1 ? "" : "s"}`);
+  return { lines, cleaned, removed };
+}
+
+// Co-rescue edges: two nodes repeatedly rescued TOGETHER by graph expansion
+// are missing a direct edge — wire one deterministically so future traversal
+// reaches them in one hop instead of relying on repeated rescues.
+function coRescueEdgesPhase(ev, { cap = 10 } = {}) {
+  const lines = [];
+  let wired = 0;
+  if (!recallGraphLib.available()) return { lines, wired };
+  for (const p of (ev?.coRescuePairs || []).slice(0, cap)) {
+    try { recallGraphLib.reinforce(p.a, p.b, 1); wired++; } catch (e) {}
+  }
+  if (wired) lines.push(`🕸 Wired ${wired} co-rescue edge${wired === 1 ? "" : "s"} — nodes that kept getting rescued together are now directly linked`);
+  return { lines, wired };
+}
+
+// Negative Hebbian: a node that keeps arriving via graph expansion but is
+// never kept and never used is firing wrongly — ease every edge pulling it
+// in. Only targets nodes with repeated graph arrivals (act ≥ 3): pure seed
+// noise is a retag/archive problem the model handles with the evidence lines.
+function negativeHebbianPhase(ev, { cap = 12 } = {}) {
+  const lines = [];
+  let nodes = 0, weakened = 0, pruned = 0;
+  if (!recallGraphLib.available()) return { lines, nodes, weakened, pruned };
+  for (const cand of ev?.neverKept || []) {
+    if (nodes >= cap) break;
+    if ((cand.act || 0) < 3) continue;
+    try {
+      const r = recallGraphLib.weakenNode(cand.id);
+      if (r.weakened || r.pruned) { nodes++; weakened += r.weakened; pruned += r.pruned; }
+    } catch (e) {}
+  }
+  if (nodes) lines.push(`🪶 Eased graph pull on ${nodes} surfaced-but-never-used node${nodes === 1 ? "" : "s"} (${weakened} edges weakened, ${pruned} pruned)`);
+  return { lines, nodes, weakened, pruned };
+}
+
 async function runDream({ trigger = "manual" } = {}) {
   if (!enabled()) return { skipped: "dream is disabled (DREAM=off)" };
   if (_dreaming) return { skipped: "a dream is already in progress" };
@@ -747,6 +991,50 @@ async function runDream({ trigger = "manual" } = {}) {
 
   _dreaming = true;
   try {
+    const nowISO = new Date().toISOString();
+    const dreamState = readDreamState();
+    const fullSweep = !dreamState.lastFullSweep ||
+      (Date.now() - Date.parse(dreamState.lastFullSweep)) / 86400000 >= FULL_SWEEP_DAYS;
+    let ev = null, windowDelta = null, clusters = [];
+    try { ev = recallMetrics.evidence(); } catch (e) {}
+    try { windowDelta = summaryDelta(ev?.summary, dreamState.summarySnapshot); } catch (e) {}
+    try { clusters = mergeClusters(packs.listPacks()); } catch (e) {}
+
+    // Closed-loop knob governance — deterministic, BEFORE the model pass so a
+    // bad change gets rolled back even on nights the model call fails.
+    const knobLines = [];
+    try {
+      const pending = dreamState.pendingKnobCheck;
+      if (pending && windowDelta && (windowDelta.turns || 0) >= 30) {
+        const h = healthOf(windowDelta);
+        const base = pending.baseline || {};
+        const rescueDown = base.rescueRate != null && h.rescueRate < base.rescueRate - Math.max(0.02, base.rescueRate * 0.2);
+        const noiseUp = base.noiseRate != null && h.noiseRate > base.noiseRate + Math.max(0.02, base.noiseRate * 0.2);
+        if (rescueDown || noiseUp) {
+          const r = recallTuning.revert(pending.knob, {
+            reason: `${rescueDown ? "rescue rate fell" : "noise rose"} over ${windowDelta.turns} turns (rescue ${(base.rescueRate * 100).toFixed(0)}%→${(h.rescueRate * 100).toFixed(0)}%, noise ${(base.noiseRate * 100).toFixed(0)}%→${(h.noiseRate * 100).toFixed(0)}%)`,
+          });
+          if (r) knobLines.push(`🎛 Rolled back ${pending.knob} to ${r.to} — the change made things worse (${rescueDown ? "rescue rate fell" : "noise rose"} over ${windowDelta.turns} turns).`);
+        } else {
+          knobLines.push(`🎛 Keeping ${pending.knob} at ${recallTuning.get(pending.knob)} — window healthy after ${windowDelta.turns} turns.`);
+        }
+        dreamState.pendingKnobCheck = null;
+      }
+      // Cascade trust check: sampled shadow judgements disagreeing with the
+      // judge means the deterministic verdicts are drifting — switch it off
+      // and let the dream re-enable it later if evidence improves.
+      if (windowDelta && (windowDelta.shadowChecks || 0) >= 20 && recallTuning.get("cascade") !== "off") {
+        const agree = (windowDelta.shadowAgree || 0) / windowDelta.shadowChecks;
+        if (agree < 0.8) {
+          const r = recallTuning.set("cascade", "off", {
+            reason: `shadow agreement ${Math.round(agree * 100)}% over ${windowDelta.shadowChecks} checks (<80%)`,
+            evidence: "dream cascade trust check",
+          });
+          if (r) knobLines.push(`🎛 Paused the walker cascade — shadow samples agreed with the judge only ${Math.round(agree * 100)}% of the time.`);
+        }
+      }
+    } catch (e) { console.warn(`[dream] knob governance failed: ${e.message}`); }
+
     // Best-effort consolidation: on a large corpus this call can time out or
     // return unreadable JSON. That must NOT abort the dream — the deterministic
     // phases below (prefix nesting, graph tend) need no model and are the
@@ -755,7 +1043,7 @@ async function runDream({ trigger = "manual" } = {}) {
     let decision = null;
     let modelFailNote = "";
     try {
-      const { text } = await spawnSubagent(buildDreamPrompt(), {
+      const { text } = await spawnSubagent(buildDreamPrompt({ sinceTs: dreamState.lastRun || null, fullSweep, clusters, evidence: ev, windowDelta }), {
         model: DREAM_MODEL,
         effort: DREAM_EFFORT,
         timeoutMs: dreamTimeoutMs(packCount),
@@ -770,13 +1058,36 @@ async function runDream({ trigger = "manual" } = {}) {
 
     const backupRoot = makeBackupRoot();
     const applied = applyDream(decision, backupRoot);
+
+    // Model-proposed knob change: bounded by tuning.js, one per night, and a
+    // baseline snapshot is kept so the next dream can auto-roll-back.
+    if (decision.tuning && decision.tuning.knob) {
+      try {
+        const t = decision.tuning;
+        const r = recallTuning.set(t.knob, t.to, { reason: String(t.reason || "dream proposal").slice(0, 200), evidence: "dream consolidation" });
+        if (r) {
+          knobLines.push(`🎛 Tuned ${r.knob}: ${r.from} → ${r.to} — ${clip(String(t.reason || ""), 140)}`);
+          dreamState.pendingKnobCheck = { ts: nowISO, knob: r.knob, from: r.from, to: r.to, baseline: healthOf(windowDelta || {}) };
+        }
+      } catch (e) { console.warn(`[dream] tuning apply failed: ${e.message}`); }
+    }
+
     // Deterministic hierarchy backfill (kazee-people-* → kazee-people), after the
     // model's parents/umbrellas decision so it only fills the obvious prefix
     // families left flat. Backed up + announced like everything else.
     let nestLines = [];
     try { nestLines = nestPrefixFamilies(backupRoot).lines; }
     catch (e) { console.warn(`[dream] nesting pass failed: ${e.message}`); }
-    const consolidationLines = applied.concat(nestLines);
+    // Evidence-driven deterministic phases — no model involved, so they run
+    // (and matter most) even on nights the consolidation call fails.
+    let journalLines = [], coRescueLines = [], hebbianLines = [];
+    try { journalLines = journalBackfillDedupe(backupRoot).lines; }
+    catch (e) { console.warn(`[dream] journal dedupe failed: ${e.message}`); }
+    try { coRescueLines = coRescueEdgesPhase(ev).lines; }
+    catch (e) { console.warn(`[dream] co-rescue pass failed: ${e.message}`); }
+    try { hebbianLines = negativeHebbianPhase(ev).lines; }
+    catch (e) { console.warn(`[dream] negative-hebbian pass failed: ${e.message}`); }
+    const consolidationLines = applied.concat(nestLines, journalLines, coRescueLines, hebbianLines, knobLines);
     let report = decision.report || (consolidationLines.length > 0 ? "Tidied up my memory overnight." : "");
     if (modelFailNote) {
       report = `Heads up — ${modelFailNote}, so I skipped the AI-led merges this round but still ran the automatic filing + graph upkeep.${report ? " " + report : ""}`;
@@ -820,12 +1131,22 @@ async function runDream({ trigger = "manual" } = {}) {
     // weights, prune orphans. Deterministic + safe, runs every dream.
     let graphNote = "";
     try {
-      const g = require("./recall/graph").tend(packs, entities);
+      const g = recallGraphLib.tend(packs, entities, { halfLifeDays: recallTuning.get("decayHalfLifeDays") });
       if (g.synced || g.decayed || g.pruned) {
         graphNote = `🕸 Recall graph: ${g.edges} edges / ${g.nodes} nodes (synced ${g.synced}, decayed ${g.decayed}, pruned ${g.pruned}).`;
       }
     } catch (e) { /* graph is best-effort */ }
 
+    // Episodic index upkeep: index any transcript turns written since the last
+    // sweep and drop rows for transcript files deleted from disk.
+    let episodicNote = "";
+    try {
+      const t = require("./transcript-index").tend();
+      if (t.available && (t.added || t.prunedFiles)) {
+        episodicNote = `🎞 Episodic index: ${t.added} new turn${t.added === 1 ? "" : "s"} indexed${t.prunedFiles ? `, ${t.prunedFiles} stale transcript${t.prunedFiles === 1 ? "" : "s"} pruned` : ""}.`;
+      }
+    } catch (e) { /* episodic index is best-effort */ }
+
     // Tool hygiene: tend the directed tool-graph (decay reinforced follows-edges,
     // prune faded/orphaned ones) and flag tools whose --pack link now dangles.
     // Read-only toward the tools themselves — a tool is never auto-deleted (that's
@@ -877,11 +1198,59 @@ async function runDream({ trigger = "manual" } = {}) {
     const staleNote = staleTaskReport();
     const dreamLines = consolidationLines.concat(introApplied);
 
+    // Memory-health line: the window's KPIs since the previous dream, so every
+    // morning report doubles as a harness performance readout.
+    let healthNote = "";
+    try {
+      if (windowDelta && windowDelta.turns > 0) {
+        const h = healthOf(windowDelta);
+        const tiers = Object.entries(windowDelta.byTier || {})
+          .filter(([, v]) => v.n > 0)
+          .map(([t, v]) => `${t} ${v.n}× (${(v.ms / v.n / 1000).toFixed(1)}s)`).join(", ");
+        const bits = [
+          `${windowDelta.turns} recall turns`,
+          `rescue ${(h.rescueRate * 100).toFixed(0)}%`,
+          `noise ${(h.noiseRate * 100).toFixed(0)}%`,
+          `avg ${(h.avgLatencyMs / 1000).toFixed(1)}s`,
+        ];
+        if (tiers) bits.push(`tiers: ${tiers}`);
+        if (windowDelta.autoKept || windowDelta.autoDropped) bits.push(`cascade kept ${windowDelta.autoKept || 0}/dropped ${windowDelta.autoDropped || 0} without the judge`);
+        if (windowDelta.shadowChecks) bits.push(`shadow agreement ${Math.round(100 * (windowDelta.shadowAgree || 0) / windowDelta.shadowChecks)}%`);
+        if (windowDelta.reviewerSkipped) bits.push(`reviewer skipped ${windowDelta.reviewerSkipped} empty turn${windowDelta.reviewerSkipped === 1 ? "" : "s"}`);
+        if (windowDelta.costUsd) bits.push(`recall spend $${windowDelta.costUsd.toFixed(2)}`);
+        healthNote = `📊 Memory health since last dream: ${bits.join(" · ")}.`;
+      }
+    } catch (e) {}
+
+    // Version-stamped KPI snapshot — one line per dream night, the series the
+    // `open-claudia kpi` report charts across versions/models.
+    try {
+      recallMetrics.appendKpi({
+        trigger, fullSweep,
+        models: {
+          walker: process.env.RECALL_DISCOVERER_MODEL || "haiku",
+          reviewer: process.env.PACK_REVIEW_MODEL || "claude-sonnet-4-6",
+          dream: DREAM_MODEL,
+        },
+        window: windowDelta || null,
+        health: windowDelta ? healthOf(windowDelta) : null,
+        knobs: Object.fromEntries(recallTuning.knobTable().map((k) => [k.name, k.current])),
+      });
+    } catch (e) {}
+
+    // Persist dream state: windowing snapshot, sweep stamp, pending knob check.
+    try {
+      dreamState.lastRun = nowISO;
+      if (fullSweep) dreamState.lastFullSweep = nowISO;
+      if (ev?.summary) dreamState.summarySnapshot = ev.summary;
+      writeDreamState(dreamState);
+    } catch (e) { console.warn(`[dream] state write failed: ${e.message}`); }
+
     const reportPath = writeDreamReport({
       model: DREAM_MODEL, effort: DREAM_EFFORT, trigger,
       consolidation: { report: decision.report, lines: consolidationLines },
       introspection: { report: introReport, lines: introApplied, proposed: introProposed },
-      graphNote, toolNote, staleNote, backupRoot,
+      healthNote, graphNote, episodicNote, toolNote, staleNote, backupRoot,
     });
 
     // Richer chat summary: consolidation + introspection narrative + what
@@ -889,19 +1258,21 @@ async function runDream({ trigger = "manual" } = {}) {
     const parts = [];
     if (report) parts.push(`💤 ${report}`);
     if (introReport) parts.push(`🪞 ${introReport}`);
+    if (healthNote) parts.push(healthNote);
     if (dreamLines.length) parts.push(dreamLines.join("\n"));
     if (introProposed) {
       const n = (introProposed.lessons_add?.length || 0) + (introProposed.doc_edits?.length || 0) + (introProposed.entity_edits?.length || 0) + (introProposed.ideas?.length || 0);
       if (n) parts.push(`📋 ${n} self-improvement change(s) staged for your OK (DREAM_SELF_APPLY=off) — see the log below.`);
     }
     if (graphNote) parts.push(graphNote);
+    if (episodicNote) parts.push(episodicNote);
     if (toolNote) parts.push(toolNote);
     if (staleNote) parts.push(staleNote);
     if (dreamLines.length) parts.push(`🗄 Anything changed or merged away is backed up under ${backupRoot}`);
     if (reportPath) parts.push(`📔 Full dream log: ${reportPath}`);
     const message = parts.length ? parts.join("\n\n") : "";
 
-    return { applied: dreamLines, report, introReport, message, staleNote, graphNote, toolNote, reportPath, trigger };
+    return { applied: dreamLines, report, introReport, message, healthNote, staleNote, graphNote, episodicNote, toolNote, reportPath, trigger, fullSweep };
   } finally {
     _dreaming = false;
   }
@@ -937,6 +1308,8 @@ function initDream(adapters) {
 module.exports = {
   runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers, nestPrefixFamilies, dreamTimeoutMs,
   buildIntrospectionPrompt, parseIntrospection, applyIntrospection, writeDreamReport,
+  summaryDelta, healthOf, mergeClusters, selectDumpDirs, journalBackfillDedupe,
+  coRescueEdgesPhase, negativeHebbianPhase, readDreamState, writeDreamState,
   enabled, summaryEnabled, introspectEnabled, selfApplyEnabled,
-  DREAM_CRON, DREAM_MODEL, DREAM_EFFORT, PROMOTE_MIN_PROJECTS,
+  DREAM_CRON, DREAM_MODEL, DREAM_EFFORT, PROMOTE_MIN_PROJECTS, DREAM_STATE_FILE, FULL_SWEEP_DAYS,
 };

package/core/pack-review.js

@@ -294,12 +294,40 @@ function applyLessonAction(l) {
   return { kind: "skipped", reason: r.reason || "not added" };
 }
 
+// Correction/preference language: a short turn carrying any of these may hold
+// a Stance-worthy signal, so it always goes to the reviewer regardless of the
+// deterministic skip below.
+const PREFERENCE_RE = /\b(no|not|wrong|actually|instead|don'?t|never|always|prefer|remember|rule|stop|from now on|should)\b/i;
+
+// Deterministic reviewer skip-gate. Only skips what is PROVABLY empty:
+//   short   — combined turn text under the floor (pre-existing behaviour).
+//   trivial — recall tier "skip": pleasantry/ack turns.
+//   lookup  — seeds-tier command turn where the harness AFFIRMED no write-ish
+//             tool ran (signals.wrote === false), the exchange is small, and
+//             the user text carries no correction/preference language. A pure
+//             status lookup has nothing to journal; anything ambiguous
+//             (wrote undefined, long reply, preference words) still reviews —
+//             accuracy first, the gate only trims provable no-ops.
+function shouldSkipReview({ userText, assistantText, signals = {} }) {
+  const combined = (String(userText || "") + String(assistantText || "")).trim();
+  if (combined.length < MIN_TURN_CHARS) return "short";
+  if (signals.tier === "skip") return "trivial";
+  if (signals.tier === "seeds" && signals.wrote === false && combined.length < 1500
+      && !PREFERENCE_RE.test(String(userText || ""))) return "lookup";
+  return null;
+}
+
 // Fire-and-forget. `announce` is an async (text) => void bound to the
 // originating channel; failures are logged, never thrown into the turn.
-function reviewTurn({ userText, assistantText, channelId, announce }) {
+function reviewTurn({ userText, assistantText, channelId, announce, signals }) {
   if (!enabled()) return;
-  const combined = (String(userText || "") + String(assistantText || "")).trim();
-  if (combined.length < MIN_TURN_CHARS) return;
+  const skip = shouldSkipReview({ userText, assistantText, signals });
+  if (skip) {
+    if (skip !== "short") { // count only the new gate's savings, not the old floor
+      try { require("./recall/metrics").logReviewerSkip(); } catch (e) {}
+    }
+    return;
+  }
 
   const prompt = buildReviewPrompt(redactSensitive(String(userText || "")), redactSensitive(String(assistantText || "")));
 
@@ -379,4 +407,4 @@ function reviewTurn({ userText, assistantText, channelId, announce }) {
   });
 }
 
-module.exports = { reviewTurn, parseDecision, applyAction, applyEntityAction, applyLessonAction, buildReviewPrompt, clipWords, ENTITY_EMOJI };
+module.exports = { reviewTurn, shouldSkipReview, parseDecision, applyAction, applyEntityAction, applyLessonAction, buildReviewPrompt, clipWords, ENTITY_EMOJI };