@inetafrica/open-claudia 3.0.44 → 3.1.0

package/core/tool-graph.js

@@ -23,6 +23,14 @@
 // and traversed directionally. Each edge carries a Hebbian `weight` bumped on
 // co-use and decayed over time; unlike pack edges there is no structural floor,
 // so a chain that stops being used eventually decays away and is pruned.
+//
+// Decay is computed ON READ (same doctrine as core/recall/graph.js): the stored
+// `weight` is the value AS OF `last_reinforced`; reads map it through
+// effectiveWeight() and reinforcement settles accrued decay before bumping.
+// Nothing rewrites weights nightly — tend() only physically deletes edges whose
+// effective weight has faded under `pruneBelow`. The old nightly decay()
+// rewrite compounded (full age reapplied to an already-decayed weight each
+// night), emptying chains in days; that path no longer exists.
 
 const fs = require("fs");
 const path = require("path");
@@ -37,8 +45,8 @@ const GRAPH_DB = process.env.TOOL_GRAPH_DB
 
 // Tunables (overridable via dream knobs later).
 const DEFAULTS = {
-  halfLifeDays: 45,   // Hebbian weight half-life for decay()
-  pruneBelow: 0.15,   // edges decayed under this are dropped (no structural floor)
+  halfLifeDays: 45,   // Hebbian weight half-life for read-time decay
+  pruneBelow: 0.15,   // edges whose effective weight falls under this are dead (no structural floor)
 };
 
 let _db = null;
@@ -82,6 +90,18 @@ function openDb() {
     )`);
     db.exec("CREATE INDEX IF NOT EXISTS pack_tool_edges_pack ON pack_tool_edges (pack)");
     db.exec("CREATE INDEX IF NOT EXISTS pack_tool_edges_tool ON pack_tool_edges (tool)");
+    // v1 migration: legacy DBs carry weights the old nightly decay() rewrite
+    // had already over-decayed (compounding). Treat stored values as current
+    // and restart the clock — decay is read-time from here on.
+    try {
+      const uv = db.prepare("PRAGMA user_version").get() || {};
+      if (Number(uv.user_version || 0) < 1) {
+        const stamp = now();
+        db.prepare("UPDATE tool_edges SET last_reinforced=? WHERE last_reinforced IS NOT NULL").run(stamp);
+        db.prepare("UPDATE pack_tool_edges SET last_reinforced=? WHERE last_reinforced IS NOT NULL").run(stamp);
+        db.exec("PRAGMA user_version = 1");
+      }
+    } catch (e) {}
     _db = db;
     return db;
   } catch (e) {
@@ -91,23 +111,49 @@ function openDb() {
 
 function now() { return new Date().toISOString(); }
 
-// Directed upsert of a follows-edge src→dst. `bump` adds to the current weight
-// (Hebbian) and stamps last_reinforced; with no bump it just ensures the edge
-// exists at `weight` (default 1).
+// Read-time weight of an edge row: exponential decay of the stored weight since
+// last_reinforced. Pure — storage is never touched. No structural floor here;
+// an edge that was never reinforced (last_reinforced null) does not decay.
+function effectiveWeight(e, nowMs = Date.now(), halfLifeDays = DEFAULTS.halfLifeDays) {
+  if (!e || !Number.isFinite(e.weight)) return 0;
+  if (!e.last_reinforced) return e.weight;
+  const ageDays = (nowMs - Date.parse(e.last_reinforced)) / 86400000;
+  if (!(ageDays > 0)) return e.weight;
+  return e.weight * Math.exp(-Math.log(2) * ageDays / Math.max(1, halfLifeDays));
+}
+
+// Rank rows by read-time weight, dropping ones already faded under pruneBelow
+// (dead advice — physically deleted on the next tend()). Weights are rounded
+// to 4dp so a seconds-old reinforcement still reads as its whole value.
+function rankLive(rows, limit) {
+  const nowMs = Date.now();
+  return rows
+    .map((r) => ({ ...r, weight: Math.round(effectiveWeight(r, nowMs) * 1e4) / 1e4 }))
+    .filter((r) => r.weight >= DEFAULTS.pruneBelow)
+    .sort((a, b) => b.weight - a.weight
+      || String(b.last_reinforced || "").localeCompare(String(a.last_reinforced || "")))
+    .slice(0, Math.max(0, limit));
+}
+
+// Directed upsert of a follows-edge src→dst. `bump` settles the decay accrued
+// since last_reinforced, adds to the effective weight (Hebbian) and restamps;
+// with no bump it just ensures the edge exists at `weight` (default 1).
 function addFollow(src, dst, opts = {}) {
   const db = openDb();
   if (!db || !src || !dst || src === dst) return false;
   const bump = Number.isFinite(opts.bump) ? opts.bump : 0;
   const weight = Number.isFinite(opts.weight) ? opts.weight : 1;
   try {
-    const existing = db.prepare("SELECT weight FROM tool_edges WHERE src=? AND dst=?").get(src, dst);
+    const existing = db.prepare("SELECT weight, last_reinforced FROM tool_edges WHERE src=? AND dst=?").get(src, dst);
     if (existing) {
-      const next = bump ? existing.weight + bump : Math.max(existing.weight, weight);
       if (bump) {
         db.prepare("UPDATE tool_edges SET weight=?, last_reinforced=? WHERE src=? AND dst=?")
-          .run(next, now(), src, dst);
+          .run(effectiveWeight(existing) + bump, now(), src, dst);
       } else {
-        db.prepare("UPDATE tool_edges SET weight=? WHERE src=? AND dst=?").run(next, src, dst);
+        const next = Math.max(existing.weight, weight);
+        if (next !== existing.weight) {
+          db.prepare("UPDATE tool_edges SET weight=? WHERE src=? AND dst=?").run(next, src, dst);
+        }
       }
     } else {
       // No structural floor for tools: a brand-new edge is worth exactly its
@@ -148,14 +194,14 @@ function allEdges() {
   catch (e) { return []; }
 }
 
-// Tools that tend to follow `name`, strongest first. This is the surfaced
-// signal: "you ran X — you usually run these next".
+// Tools that tend to follow `name`, strongest first (read-time weights). This
+// is the surfaced signal: "you ran X — you usually run these next".
 function followers(name, limit = 5) {
   const db = openDb();
   if (!db || !name) return [];
   try {
-    return db.prepare("SELECT dst AS name, weight FROM tool_edges WHERE src=? ORDER BY weight DESC LIMIT ?")
-      .all(name, limit);
+    const rows = db.prepare("SELECT dst AS name, weight, last_reinforced FROM tool_edges WHERE src=?").all(name);
+    return rankLive(rows, limit).map((r) => ({ name: r.name, weight: r.weight }));
   } catch (e) { return []; }
 }
 
@@ -164,8 +210,8 @@ function predecessors(name, limit = 5) {
   const db = openDb();
   if (!db || !name) return [];
   try {
-    return db.prepare("SELECT src AS name, weight FROM tool_edges WHERE dst=? ORDER BY weight DESC LIMIT ?")
-      .all(name, limit);
+    const rows = db.prepare("SELECT src AS name, weight, last_reinforced FROM tool_edges WHERE dst=?").all(name);
+    return rankLive(rows, limit).map((r) => ({ name: r.name, weight: r.weight }));
   } catch (e) { return []; }
 }
 
@@ -206,7 +252,13 @@ function parseToolRuns(command) {
   const out = [];
   const cmd = String(command || "");
   if (!/tool\s+(?:run|exec)\s+/i.test(cmd)) return out;
-  for (const seg of cmd.split(/&&|\|\||[;\n]/)) {
+  // B17: split on ALL shell composition operators — &&, ||, |, &, ;, newline.
+  // The single pipe was missed, so `tool run a … | tool run b …` parsed as one
+  // segment and only the first tool earned a follows-edge. Separators inside
+  // quoted spans are neutralized first so a pipe in an argument doesn't split
+  // (quoted content never reaches the shape anyway — shapeCommand masks it).
+  const masked = cmd.replace(/(["'])(?:\\.|(?!\1).)*\1/g, (q) => q.replace(/[;\n|&]/g, " "));
+  for (const seg of masked.split(/[;\n|&]+/)) {
     const m = seg.match(/\btool\s+(?:run|exec)\s+["']?([a-z0-9][\w.-]*)["']?\s*(.*)$/i);
     if (!m) continue;
     out.push({ name: m[1], shape: shapeCommand(`${m[1]} ${m[2] || ""}`) });
@@ -227,7 +279,8 @@ function recordPackTool(pack, tool, opts = {}) {
   try {
     const row = db.prepare("SELECT weight, intent, last_reinforced FROM pack_tool_edges WHERE pack=? AND tool=? AND command=?").get(pack, tool, command);
     if (row) {
-      const next = bump ? row.weight + bump : Math.max(row.weight, weight);
+      // Bump settles accrued decay first (same invariant as addFollow).
+      const next = bump ? effectiveWeight(row) + bump : Math.max(row.weight, weight);
       const intent = (opts.intent != null && opts.intent !== "") ? String(opts.intent).slice(0, 200) : row.intent;
       db.prepare("UPDATE pack_tool_edges SET weight=?, intent=?, last_reinforced=? WHERE pack=? AND tool=? AND command=?")
         .run(next, intent, bump ? now() : row.last_reinforced, pack, tool, command);
@@ -243,15 +296,16 @@ function recordPackTool(pack, tool, opts = {}) {
 }
 
 // Strongest contextual tool usages recorded under a pack, for surfacing in that
-// pack's injected context. Ordered by reinforced weight, newest first as a
+// pack's injected context. Ordered by read-time weight, newest first as a
 // tiebreak. One row per distinct command shape.
 function packTools(pack, limit = 2) {
   const db = openDb();
   if (!db || !pack) return [];
   try {
-    return db.prepare(
-      "SELECT tool, command, intent, weight FROM pack_tool_edges WHERE pack=? ORDER BY weight DESC, last_reinforced DESC LIMIT ?"
-    ).all(pack, limit);
+    const rows = db.prepare(
+      "SELECT tool, command, intent, weight, last_reinforced FROM pack_tool_edges WHERE pack=?"
+    ).all(pack);
+    return rankLive(rows, limit).map((r) => ({ tool: r.tool, command: r.command, intent: r.intent, weight: r.weight }));
   } catch (e) { return []; }
 }
 
@@ -260,9 +314,10 @@ function toolPacks(tool, limit = 5) {
   const db = openDb();
   if (!db || !tool) return [];
   try {
-    return db.prepare(
-      "SELECT pack, command, intent, weight FROM pack_tool_edges WHERE tool=? ORDER BY weight DESC, last_reinforced DESC LIMIT ?"
-    ).all(tool, limit);
+    const rows = db.prepare(
+      "SELECT pack, command, intent, weight, last_reinforced FROM pack_tool_edges WHERE tool=?"
+    ).all(tool);
+    return rankLive(rows, limit).map((r) => ({ pack: r.pack, command: r.command, intent: r.intent, weight: r.weight }));
   } catch (e) { return []; }
 }
 
@@ -280,53 +335,25 @@ function allPackToolEdges() {
   catch (e) { return []; }
 }
 
-// Exponential time decay. Tools have no structural floor, so edges decay toward
-// zero and are pruned once under `pruneBelow` — a chain that fell out of use
-// disappears instead of lingering as stale advice. Applies to both the tool→tool
-// follows-edges and the pack↔tool contextual edges (same physics).
-function decay({ halfLifeDays = DEFAULTS.halfLifeDays, pruneBelow = DEFAULTS.pruneBelow } = {}) {
+// Physically delete edges whose EFFECTIVE weight has faded under `pruneBelow` —
+// a chain that fell out of use disappears instead of lingering as stale advice.
+// Weights themselves are never rewritten (decay-on-read); this is pure garbage
+// collection. Applies to both the tool→tool follows-edges and the pack↔tool
+// contextual edges (same physics). Never-reinforced ensure-edges don't fade.
+function prune({ halfLifeDays = DEFAULTS.halfLifeDays, pruneBelow = DEFAULTS.pruneBelow } = {}) {
   const db = openDb();
-  if (!db) return { decayed: 0, pruned: 0 };
+  if (!db) return { pruned: 0 };
   const nowMs = Date.now();
-  const ln2 = Math.log(2);
-  let decayed = 0, pruned = 0;
-  const decayFactor = (lastReinforced) => {
-    if (!lastReinforced) return null;
-    const ageDays = (nowMs - Date.parse(lastReinforced)) / 86400000;
-    if (!(ageDays > 0)) return null;
-    return Math.exp(-ln2 * ageDays / Math.max(1, halfLifeDays));
-  };
+  let pruned = 0;
   for (const e of allEdges()) {
-    const factor = decayFactor(e.last_reinforced);
-    if (factor === null) continue;
-    const next = e.weight * factor;
-    if (next < pruneBelow) {
-      if (removeEdge(e.src, e.dst)) pruned++;
-      continue;
-    }
-    if (Math.abs(next - e.weight) > 1e-6) {
-      try {
-        db.prepare("UPDATE tool_edges SET weight=? WHERE src=? AND dst=?").run(next, e.src, e.dst);
-        decayed++;
-      } catch (e2) {}
-    }
+    if (!e.last_reinforced) continue;
+    if (effectiveWeight(e, nowMs, halfLifeDays) < pruneBelow && removeEdge(e.src, e.dst)) pruned++;
   }
   for (const e of allPackToolEdges()) {
-    const factor = decayFactor(e.last_reinforced);
-    if (factor === null) continue;
-    const next = e.weight * factor;
-    if (next < pruneBelow) {
-      if (removePackTool(e.pack, e.tool, e.command)) pruned++;
-      continue;
-    }
-    if (Math.abs(next - e.weight) > 1e-6) {
-      try {
-        db.prepare("UPDATE pack_tool_edges SET weight=? WHERE pack=? AND tool=? AND command=?").run(next, e.pack, e.tool, e.command);
-        decayed++;
-      } catch (e2) {}
-    }
+    if (!e.last_reinforced) continue;
+    if (effectiveWeight(e, nowMs, halfLifeDays) < pruneBelow && removePackTool(e.pack, e.tool, e.command)) pruned++;
   }
-  return { decayed, pruned };
+  return { pruned };
 }
 
 // Drop edges whose endpoints are no longer registered tools (a tool was removed
@@ -361,13 +388,14 @@ function pruneOrphans(toolsLib, packsLib) {
   return removed;
 }
 
-// Nightly maintenance (called by the dream): decay reinforced weights and drop
-// orphaned/faded edges. Deterministic + safe — no model needed. Pass
-// { packsLib } to also prune pack↔tool edges whose pack was removed.
+// Nightly maintenance (called by the dream): drop faded and orphaned edges.
+// No weight pass — decay is applied on read. Deterministic + safe — no model
+// needed. Pass { packsLib } to also prune pack↔tool edges whose pack was
+// removed.
 function tend(toolsLib, opts = {}) {
-  const { decayed, pruned } = decay(opts);
+  const { pruned } = prune(opts);
   const orphaned = toolsLib ? pruneOrphans(toolsLib, opts.packsLib) : 0;
-  return { decayed, pruned: pruned + orphaned, ...stats() };
+  return { pruned: pruned + orphaned, ...stats() };
 }
 
 function stats() {
@@ -384,7 +412,7 @@ module.exports = {
   DEFAULTS, GRAPH_DB,
   available, openDb,
   addFollow, reinforceSequence, removeEdge, allEdges,
-  followers, predecessors, decay, pruneOrphans, tend, stats,
+  followers, predecessors, effectiveWeight, prune, pruneOrphans, tend, stats,
   shapeCommand, parseToolRuns, recordPackTool, packTools, toolPacks,
   removePackTool, allPackToolEdges,
   _resetForTest,

package/core/tools.js

@@ -30,6 +30,7 @@ const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
 const CONFIG_DIR = require("../config-dir");
+const { atomicWriteFileSync } = require("./fsutil");
 
 const TOOLS_DIR = process.env.TOOLS_DIR ? path.resolve(process.env.TOOLS_DIR) : path.join(CONFIG_DIR, "tools");
 
@@ -90,7 +91,7 @@ function readUsage() {
 }
 
 function writeUsage(u) {
-  try { ensureDir(); fs.writeFileSync(USAGE_FILE, JSON.stringify(u), { mode: 0o600 }); }
+  try { ensureDir(); atomicWriteFileSync(USAGE_FILE, JSON.stringify(u), { mode: 0o600 }); }
   catch (e) { /* best-effort */ }
 }
 
@@ -106,7 +107,7 @@ function writeState(name, s) {
   const file = p.state || path.join(TOOLS_DIR, sanitizeName(name), "state.json");
   try {
     fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-    fs.writeFileSync(file, JSON.stringify(s, null, 1), { mode: 0o600 });
+    atomicWriteFileSync(file, JSON.stringify(s, null, 1), { mode: 0o600 });
   } catch (e) { /* best-effort */ }
 }
 

package/core/turn-observer.js

@@ -13,6 +13,9 @@
 const { chatContext, currentAdapter } = require("./context");
 const { send } = require("./io");
 
+// Consecutive recall failures on one channel before the owner is alerted (B5).
+const RECALL_FAILURE_ALERT_AFTER = 3;
+
 function esc(s) {
   return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -71,8 +74,27 @@ function createTurnObserver({ state, store }) {
   // 🧠 /recall + 🔧 /tooltrace banners, fired once the prompt bundle (and its
   // recall metadata) exists — before the provider spawns, like v2.15.
   const onRecallSurfaced = (metadata) => {
-    if (guarded) return;
     const r = metadata;
+    // B5: recall fails OPEN (the turn proceeds without memory), so a persistent
+    // breakage is invisible unless someone counts. Track consecutive failures
+    // on channel state and tell the owner once per streak — a one-off transient
+    // stays quiet, an outage does not.
+    if (r && r.reason === "optional_recall_unavailable") {
+      state.recallFailureStreak = (state.recallFailureStreak || 0) + 1;
+      if (settings.showRecall) {
+        notify("banner:recall", "🧠 Recall FAILED this turn — I'm answering without pack/entity/tool memory. See bot log: [recall] builder failed.");
+      }
+      if (state.recallFailureStreak === RECALL_FAILURE_ALERT_AFTER) {
+        notify("alert:recall-failure", [
+          `⚠️ Memory recall has failed ${state.recallFailureStreak} turns in a row — I'm running without pack/entity/tool context.`,
+          r.detail ? `Last error: ${r.detail}` : null,
+          "Check the bot log for \"[recall] builder failed\". I'll stay quiet until it recovers or breaks again.",
+        ].filter(Boolean).join("\n"));
+      }
+    } else if (r && !r.omitted) {
+      state.recallFailureStreak = 0;
+    }
+    if (guarded) return;
     if (!r || r.omitted) return;
     const fmt = (arr, icon) => (arr || []).map((x) => (x.why ? `${icon} <b>${esc(x.name)}</b> — ${esc(x.why)}` : `${icon} <b>${esc(x.name)}</b>`));
     if (settings.showRecall) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.44",
+  "version": "3.1.0",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {
@@ -9,7 +9,7 @@
   "scripts": {
     "setup": "node setup.js",
     "start": "node bot.js",
-    "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-refusal-recovery.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-credential-capture.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js && node test-kazee-channel-health.js && node test-prompt-budget.js && node test-agency-ledger.js && node test-agency-deliberate.js && node test-guardrail.js && node test-spaces-comment-content.js",
+    "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-turn-observer.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-refusal-recovery.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-credential-capture.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js && node test-kazee-channel-health.js && node test-prompt-budget.js && node test-agency-ledger.js && node test-agency-deliberate.js && node test-guardrail.js && node test-spaces-comment-content.js && node test-boot-health.js && node test-lexical-floor.js && node test-safe-mode.js",
     "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-runner-watchdog-static.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-walker-score.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-score-gate.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-cokept-warming.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-pack-nesting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-pack-search.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-extractive-injection.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tooling-mode.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-manifest.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-evolution.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-approval-async.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-unified-identity.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-queue-routing.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-packs.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-speaker-persona.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-pipeline.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-relationship-gate.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-relationship.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-enforcer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-identity-prune.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-kazee-message-id.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-delivery-contract.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-run-lock.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-web-sessions.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-poll-recovery.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-409-grace.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-conflict-heal-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-single-instance.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-streaming-split.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-spaces-autoenable.js"
   },
   "files": [
@@ -132,7 +132,7 @@
   "license": "MIT",
   "type": "commonjs",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=24.0.0"
   },
   "dependencies": {
     "node-cron": "^4.2.1",

package/test-extractive-injection.js

@@ -67,4 +67,25 @@ assert.ok(/#### Stance/.test(outHeadline), "headline still shows Stance");
 assert.ok(!outHeadline.includes("The ArgoCD sync for payments"), "headline does NOT inline State (unchanged legacy behavior)");
 assert.ok(/not shown/.test(outHeadline), "headline still points to hidden sections");
 
+// ── LOCKED hoist: a Stance line carrying LOCKED (uppercase) is pulled under
+//    a binding-constraints header in every mode; prose "locked" stays put ──
+const lockedPack = {
+  ...pack,
+  dir: "coders-africa",
+  sections: {
+    ...pack.sections,
+    Stance: "Audience-first design.\nLOCKED: heading font is Marcellus, body font is Nunito.\nThe staging door is locked after 18:00.",
+  },
+};
+const outLockedX = formatPackForContext(lockedPack, packsLib, { extractive: true, matchedLines: [] });
+assert.ok(/BINDING CONSTRAINTS \(LOCKED/.test(outLockedX), "extractive mode hoists LOCKED lines under the binding header");
+assert.ok(/- LOCKED: heading font is Marcellus, body font is Nunito\./.test(outLockedX), "the LOCKED line is bulleted verbatim");
+const bindingIdx = outLockedX.indexOf("BINDING CONSTRAINTS");
+assert.ok(bindingIdx !== -1 && bindingIdx < outLockedX.indexOf("Audience-first design."), "binding block leads the Stance section");
+assert.ok(outLockedX.includes("The staging door is locked after 18:00."), "lowercase 'locked' prose is not hoisted");
+assert.strictEqual((outLockedX.match(/heading font is Marcellus/g) || []).length, 1, "hoisted line is moved, not duplicated");
+assert.ok(/BINDING CONSTRAINTS \(LOCKED/.test(formatPackForContext(lockedPack, packsLib, { headline: true })), "headline mode hoists too");
+assert.ok(/BINDING CONSTRAINTS \(LOCKED/.test(formatPackForContext(lockedPack, packsLib, {})), "full mode hoists too");
+assert.ok(!/BINDING CONSTRAINTS/.test(out), "packs without LOCKED lines are untouched");
+
 console.log("extractive injection OK");

package/test-memory-mutation-queue.js

@@ -15,6 +15,7 @@ fs.mkdirSync(process.env.OPEN_CLAUDIA_CONFIG_DIR, { recursive: true });
 const {
   MemoryMutationQueue,
   MutationQueueError,
+  inspectLock,
 } = require("./core/memory-mutation-queue");
 const { atomicWriteFileSync } = require("./core/fsutil");
 
@@ -62,14 +63,12 @@ async function main() {
     journalFile,
     maxPending: 2,
     lockPollMs: 5,
-    staleLockMs: 10,
   });
   const liveContender = new MemoryMutationQueue({
     lockDir: liveLockDir,
     journalFile,
     maxPending: 2,
     lockPollMs: 5,
-    staleLockMs: 10,
     lockTimeoutMs: 50,
   });
   const liveMutation = liveOwner.enqueue("long-dream", async () => liveGate.promise);
@@ -92,11 +91,42 @@ async function main() {
     lockDir: deadLockDir,
     journalFile,
     lockPollMs: 5,
-    staleLockMs: 10,
     lockTimeoutMs: 200,
   });
   assert.strictEqual(await deadRecovery.enqueue("recover-dead-lock", async () => "recovered"), "recovered");
 
+  // Container pid-1 reuse: a lock left by a CRASHED incarnation of this same
+  // pid (different bootId) must be broken immediately — pid-liveness alone
+  // reads it as held forever, which starved reviewers on restarting pods.
+  const rebootLockDir = path.join(root, "reboot-stale.lock");
+  fs.mkdirSync(rebootLockDir);
+  fs.writeFileSync(path.join(rebootLockDir, "owner.json"),
+    JSON.stringify({ token: "prev", pid: process.pid, bootId: "previous-incarnation" }));
+  const rebootRecovery = new MemoryMutationQueue({
+    lockDir: rebootLockDir,
+    journalFile,
+    lockPollMs: 5,
+    lockTimeoutMs: 200,
+  });
+  assert.strictEqual(await rebootRecovery.enqueue("recover-reboot-lock", async () => "recovered"), "recovered",
+    "a lock from a previous incarnation sharing our pid is broken immediately");
+  assert.strictEqual(
+    inspectLock(rebootLockDir).held, false,
+    "inspectLock reports a released lock as not held");
+
+  // Orphan: mkdir succeeded but owner.json never landed (crash mid-acquire).
+  const orphanLockDir = path.join(root, "orphan.lock");
+  fs.mkdirSync(orphanLockDir);
+  fs.utimesSync(orphanLockDir, old, old);
+  assert.strictEqual(inspectLock(orphanLockDir).stale, true, "an aged ownerless lock dir reads as stale");
+  const orphanRecovery = new MemoryMutationQueue({
+    lockDir: orphanLockDir,
+    journalFile,
+    lockPollMs: 5,
+    lockTimeoutMs: 200,
+  });
+  assert.strictEqual(await orphanRecovery.enqueue("recover-orphan-lock", async () => "recovered"), "recovered");
+
   const failureQueue = new MemoryMutationQueue({
     lockDir: path.join(root, "failure.lock"),
     journalFile,

package/test-provider-compaction.js

@@ -122,6 +122,11 @@ async function immutableSuccessProbe() {
   assert.strictEqual(contexts[1].permissionMode, "plan");
   assert.strictEqual(contexts[1].maxTurns, 1);
   assert.strictEqual(contexts[1].timeoutMs, contexts[0].timeoutMs);
+  assert.strictEqual(contexts[0].purpose, "compact-summary");
+  assert.strictEqual(contexts[0].recallQuery, null, "summary stage carries no recall query");
+  assert.strictEqual(contexts[1].purpose, "compact-seed");
+  assert.ok(String(contexts[1].recallQuery || "").includes("A sufficiently detailed condensed continuation"),
+    "seed recall query carries the condensed brief, not seed-prompt boilerplate");
   const restrictedEnv = runner.decorateForegroundInvocation(
     { env: { FIXTURE_SAFE: "1" } },
     contexts[0],

package/test-provider-core-prompt.js

@@ -164,6 +164,9 @@ async function probe() {
     assert.strictEqual(omitted.userPrompt, "RECALL FAILURE USER SENTINEL");
     assert.strictEqual(omitted.recallMetadata.status, "omitted");
     assert.strictEqual(omitted.recallMetadata.omitted, true);
+    assert.strictEqual(omitted.recallMetadata.reason, "optional_recall_unavailable");
+    assert.strictEqual(omitted.recallMetadata.detail, "fixture optional recall failure",
+      "the swallowed recall error surfaces in metadata for the owner alert");
     assert.ok(omitted.coreInstructions.includes("## Delivery"));
     assert.ok(omitted.dynamicContext.includes("## Runtime state"));
 

package/test-provider-language.js

@@ -99,7 +99,54 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // ids all forced fresh) and the refused prompt is auto-retried exactly ONCE in
 // a fresh session behind a ♻️ notice. A refusal on already-fresh context gets
 // no retry (the new message itself is the problem); capture runs never retry.
-assert.strictEqual(pkg.version, "3.0.44", "release version must remain unchanged without explicit approval");
+// 3.0.45 approved by Sumeet 2026-07-20 ("Ok so you ready to implement?"): first
+// fix batch from the 2026-07-20 blind code review. Recall-graph decay moves to
+// decay-on-read (the nightly rewrite compounded — a 60d half-life emptied in
+// ~10 nights; one-time user_version 0→1 restamp, dream-tunable half-life);
+// keyring/tool-state/tuning writes become crash-safe (atomic temp+fsync+rename,
+// keyring .bak snapshot with read-through repair); recall failures alert after
+// 3 consecutive memoryless turns instead of degrading silently; the recall
+// pre-gate strips pleasantry prefixes so "ok deploy … now" recalls; tool-run
+// creds are preflighted BEFORE an approval token is consumed (a missing key no
+// longer burns the human's Approve); tool-graph parsing splits on | and &;
+// raw NUL bytes in discoverer.js/state.js become \u0000 escapes; README
+// corrected — discoverer is the shipped default engine, classic the opt-out.
+// 3.0.45 second wave folded in per Sumeet 2026-07-20 ("i think just wok
+// through all these features and fold them into .45?"): the memory-substrate
+// revival. Root cause: pods on node:20 have no node:sqlite, so pack FTS, the
+// recall graph and episodes silently never initialized — rahilcoder ran 16
+// days with seedsTotal=0 while repeating corrected branding mistakes, and its
+// reviewer starved 87% of runs on a stale mutation lock (container pid-1
+// reuse made a crashed incarnation's lock look alive forever). Ships:
+// Dockerfile.base FROM node:24-slim (+ CI build image node:24); a /doctor
+// memory-health section (substrate hard-fail, graph stats, 24h recall
+// pipeline, reviewer health, mutation lock, deferred reviews, corpus caps,
+// disk) with a deduped boot-time substrate alert and a post-upgrade doctor
+// gate on all three /upgrade paths; a pure-JS lexical seed floor under
+// matchPacks/matchEntities (recall degrades to keyword matching, never to
+// OFF — parity-tested with and without the sim-no-sqlite shim); the
+// mutation-queue lock gains a boot id + ownerless-lock grace so pid-1 reuse
+// can't wedge it, plus a reviewer retry+defer seatbelt; LOCKED Stance lines
+// hoist under a BINDING CONSTRAINTS header and the reviewer must carry them
+// verbatim and journal violations; compaction recall is fixed (summary
+// meta-turn skips recall; the fresh seed matches on condensed brief + open
+// task titles, not prompt boilerplate).
+// 3.1.0 approved by Sumeet 2026-07-20 ("yes that's fine but if in hard boot
+// loop it shoyuld give the user a way to get back online and diagnose or fall
+// back into a safe mode or something to have it fixed or set up or downgrade,
+// actually i think that's improtant as well to have a downgrade, i think add
+// this all in and let's bump the minor to 3.1.0"): the substrate-revival
+// fold graduates to a minor because boot semantics change. node:sqlite is now
+// REQUIRED — a missing substrate boots into SAFE MODE (adapters + diagnostic
+// slash commands only; no agent turns, crons, or memory writes) instead of
+// silently degrading; MEMORY_ALLOW_DEGRADED=1 or a one-shot /safemode
+// continue is the explicit keyword-only escape hatch. A boot crash loop (3
+// consecutive boots dying before 5min stable uptime) also lands in safe mode
+// so the operator keeps a live chat to rescue from instead of a dead pod.
+// New /downgrade rolls back to the previously-running version from boot
+// history (strict semver-validated target); /upgrade//downgrade clear the
+// crash counter as deliberate fix attempts. package.json engines >=24.
+assert.strictEqual(pkg.version, "3.1.0", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }

package/test-provider-recall.js

@@ -253,6 +253,39 @@ async function main() {
   recall.getEngine = originalGetEngine;
   assert.strictEqual(admittedProvider, "codex");
 
+  // ── compaction recall policy: the summary meta-turn skips recall entirely;
+  //    the seed turn matches on the runner-supplied recallQuery (condensed
+  //    brief + task titles), never the seed prompt's boilerplate ──
+  const summarySkip = await systemPrompt.buildOptionalRecallContext(
+    "Summarize this conversation for a fresh compacted continuation.",
+    {
+      state: mutableState,
+      runContext: { provider: "claude", purpose: "compact-summary", project: { name: "project-a", dir: root }, sessionId: null, runId: "compact-sum" },
+    },
+  );
+  assert.strictEqual(summarySkip.metadata.status, "omitted", "summary turn skips recall");
+  assert.strictEqual(summarySkip.metadata.reason, "compaction_meta_turn");
+  assert.strictEqual(summarySkip.dynamicContext, "");
+
+  let seedQueryText = null;
+  recall.getEngine = () => ({
+    name: "fixture",
+    async run(ctx) {
+      seedQueryText = ctx.userText;
+      return { packBlock: "", entityBlock: "", toolBlock: "", episodeBlock: "", packMatches: [], entityMatches: [] };
+    },
+  });
+  await systemPrompt.buildOptionalRecallContext(
+    "This is a compacted continuation of a previous Open Claudia session. Treat the following summary as the prior conversation context.",
+    {
+      state: mutableState,
+      runContext: { provider: "claude", purpose: "compact-seed", recallQuery: "coders africa branding fonts\nFinalize v3.0.45", project: { name: "project-a", dir: root }, sessionId: null, runId: "compact-seed" },
+    },
+  );
+  recall.getEngine = originalGetEngine;
+  assert.strictEqual(seedQueryText, "coders africa branding fonts\nFinalize v3.0.45",
+    "seed recall matches on recallQuery, not the seed prompt");
+
   for (const file of ["core/recall-filter.js", "core/recall/discoverer.js", "core/recall/warm-walker.js"]) {
     const source = fs.readFileSync(path.join(__dirname, file), "utf8");
     assert.ok(!source.includes("spawnSubagent"), `${file} no longer uses the compatibility sub-agent path`);

package/test-recall-discoverer.js

@@ -53,6 +53,14 @@ assert.strictEqual(disc.recallTier("restart bot", 3), "seeds", "short command
 assert.strictEqual(disc.recallTier("show fup logs", 2), "seeds", "≤4 words → seeds-only tier");
 assert.strictEqual(disc.recallTier("yes we need to see the 100", 2), "full", "substantive yes-prefixed turn → full");
 assert.strictEqual(disc.recallTier("how do I deploy the mobile app", 4), "full", "substantive → full");
+// B2: a pleasantry prefix is stripped BEFORE tiering, so a short real request
+// wearing an ack is no longer swallowed by the ≤4-word pleasantry skip.
+assert.strictEqual(disc.recallTier("ok deploy kazee now", 3), "seeds", "ack-prefixed 4-word command → seeds, not skip");
+assert.strictEqual(disc.recallTier("yes deploy it", 4), "seeds", "approval + command → seeds, not skip");
+assert.strictEqual(disc.recallTier("thanks! restart euvy bot", 3), "seeds", "thanks-prefixed command → seeds, not skip");
+assert.strictEqual(disc.needsRecall("ok deploy kazee now", 0), true, "prefixed command needs recall");
+assert.strictEqual(disc.recallTier("ok thanks sounds good perfect", 5), "skip", "stacked pure pleasantries skip at any length");
+assert.strictEqual(disc.recallTier("morning check the kazee deploys", 2), "seeds", "greeting stripped → remainder tiers as a short command");
 
 // --- shared stub corpus + helpers ---
 const packs = {