@inetafrica/open-claudia 3.0.37 → 3.0.41

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v3.0.41 — Verbose off now means a clean chat: the "Let me…" narration no longer lingers
+
+- **With `/verbose` off, the interim progress message is now removed once a turn settles, so the chat is left with only the final answer.** During a multi-step turn the bot posts a throttled "working…" preview that shows the short "Let me check…/Let me look at…" narration emitted before each tool call. That preview used to *stay* — settling into a permanent message — regardless of `/verbose`, which only ever gated the extended-thinking (🧠) stream. So even with verbose off you'd be left with the narration trail as a leftover message that reads like thinking-out-loud. `finalizeStreamPreview` now deletes that preview when verbose is off; `/verbose on` still keeps the narration trail. Live progress during long turns is unchanged either way — the cleanup only affects what remains after the turn ends.
+- **Agent-space / OpenClaw:** no new deps, env, or schema change; Docker image builds FROM the existing `:base`. Pure delivery-path change in `core/runner.js`; existing pods pick it up on their next approved upgrade.
+
+## v3.0.40 — Sharper recall: surfaces the actual matched facts, drops weakly-relevant ones (third cut of the Pass-4 release)
+
+- **On-open pack/entity injection is now extractive, not a headline.** Opening a pack used to inject its one-line description, hiding the facts that actually matched in State/Procedure/Journal. It now injects the Stance verbatim plus the specific fuzzy-matched lines (section-tagged), so the model sees the real matched content rather than a summary of it. Toggle with `RECALL_EXTRACTIVE` (default on).
+- **A walker score-gate drops weakly-relevant nodes.** The cheap recall walker is a pure router now — it emits `{id, why, score 0-100}` and never paraphrases. Nodes it keeps below the relevance floor (`RECALL_MIN_RELEVANCE_SCORE`, default 55) are gated out on full-tier walks, and the cascade is tightened so sticky auto-keeps are routed back to the judge instead of leaking in. Fails open (a garbled walk bypasses the gate).
+- **A KPI ruler stamps each version.** Per-turn recall records now carry kept-node scores, gate activity, and warmings; the KPI table/HTML report aggregate them per version so each release freezes as a comparable baseline (`relevance`, `gate`, `warm` columns).
+- **Co-kept Hebbian warming ships dark (default OFF).** A weaker-than-co-open reinforcement for pairs the walker co-injected, guarded by score floor + a message-grounded endpoint + a top-N cap. It writes persistent graph state so it can't be validated in one session — left off (`RECALL_COKEPT_WARMING`) pending real-traffic evaluation.
+- **Escape hatch + measurement caveat.** `/engine classic` reverts to the prior behaviour if anything regresses. Two reviewer-side measurement refinements (used-the-right-fact line-level adjudication, and shadow-delta scoring) were deferred to the separate in-flight shadow-delta task — they change how recall is *measured*, not what ships here.
+- **Agent-space / OpenClaw:** no new deps, no new env required (all `RECALL_*` knobs have defaults), no schema change; Docker image builds FROM the existing `:base`. Covered by new `test-pack-search.js`, `test-walker-score.js`, `test-extractive-injection.js`, `test-score-gate.js`, and `test-cokept-warming.js`. Existing pods pick this up on their next approved upgrade. (Two earlier cuts failed CI before publishing anything: v3.0.38 bumped the version but not the release-pin guard in `test-provider-language.js`; v3.0.39 fixed that but `test-cokept-warming.js` asserted a sqlite-graph write that no-ops on CI's `node:20` — it now skips that path when `node:sqlite` is absent, like `test-recall-graph.js`. Both were verified locally by running the suite with `node:sqlite` simulated absent, reproducing the CI environment.)
+
 ## v3.0.37 — Silent background watches, and pasted secrets are accepted on any provider
 
 - **You can now arm a watch: a background poll that stays out of the chat and only wakes me when its condition is actually met.** A watch is just a cron carrying a shell `check` command — each tick runs the check with output discarded, and *only* an exit 0 wakes the agent (with a `🔔 Watch "<label>" triggered` notice and a normal reply). A non-zero exit is the idle case: nothing hits the chat, the poll's activity goes to an append-only `watch.log`, and the job stays pending for the next tick. Watches default to **one-shot** (fire once, then remove) so a matched condition can't spam you; add `--repeat` to keep polling. Create/manage from the CLI (`open-claudia watch-add "<check>" "<wake-prompt>" [--every "<cron>"] [--repeat]`, `watch-list`, `watch-remove`), and the owner can flip the global master switch with **`/watch on|off`** (watches are owner-gated because the check is raw shell). Rides the migration-verified jobs store untouched — `check`/`repeat` survive as extra fields, zero schema change.

package/bin/pack.js

@@ -1,7 +1,8 @@
 // CLI: inspect and manage context packs (living skills+memory docs).
 //   open-claudia pack list
 //   open-claudia pack show <dir>
-//   open-claudia pack match "<text>"        — debug the router
+//   open-claudia pack match "<text>"        — debug the router (whole-pack)
+//   open-claudia pack search "<query>"      — per-line extractive search
 //   open-claudia pack migrate               — fold ~/.claude/skills into packs
 //   open-claudia pack remove <dir>
 //   open-claudia pack reindex
@@ -124,6 +125,22 @@ function run(args) {
       break;
     }
 
+    case "search": {
+      let dir = null, k = 8;
+      const words = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--pack") { dir = rest[++i]; continue; }
+        if (rest[i] === "--k") { k = Math.max(1, parseInt(rest[++i], 10) || 8); continue; }
+        words.push(rest[i]);
+      }
+      const query = words.join(" ");
+      if (!query) { console.error('Usage: pack search "<query>" [--pack <dir>] [--k N]'); process.exitCode = 1; return; }
+      const hits = packs.searchLines(query, { dir, k });
+      if (hits.length === 0) return console.log("No matching lines.");
+      for (const h of hits) console.log(`${String(h.score).padStart(3)}  ${h.dir}/${h.section}:${h.lineno}  ${h.text}`);
+      break;
+    }
+
     case "remove": {
       const removed = packs.removePack(rest[0]);
       if (!removed) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
@@ -176,7 +193,7 @@ function run(args) {
     }
 
     default:
-      console.log("Usage: open-claudia pack [list|skills|abilities|skill <dir> [on|off]|kind <dir> <ability|context>|show <dir>|match \"<text>\"|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
+      console.log("Usage: open-claudia pack [list|skills|abilities|skill <dir> [on|off]|kind <dir> <ability|context>|show <dir>|match \"<text>\"|search \"<query>\" [--pack <dir>] [--k N]|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
   }
 }
 

package/core/packs.js

@@ -641,11 +641,61 @@ function matchPacks(text, { limit = 3, threshold = null } = {}) {
     .map(([dir, score]) => ({ dir, name: names.get(dir) || dir, score }));
 }
 
+// Extractive per-line search. Where matchPacks routes whole packs, this
+// returns the individual lines that best match the query, tagged by section,
+// so the injector can surface a verbatim fact from anywhere in a pack — not
+// just Stance. Deliberately JS-side (no second FTS table) so it can never
+// disturb the load-bearing whole-pack index in reindex(). Fuzz comes from
+// substring matching: term "deploy" also hits "deployment"/"deployed".
+function searchLines(query, { dir = null, k = 8, minScore = 1 } = {}) {
+  const terms = queryTerms(query);
+  if (terms.length === 0) return [];
+  let packs;
+  if (dir) {
+    const p = readPack(dir);
+    packs = p ? [p] : [];
+  } else {
+    packs = listPacks().filter((p) => !p.archived);
+  }
+  const hits = [];
+  for (const p of packs) {
+    for (const section of SECTIONS) {
+      const body = p.sections?.[section] || "";
+      if (!body) continue;
+      const lines = body.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.length < 3) continue; // skip blanks / stray punctuation
+        const low = trimmed.toLowerCase();
+        let distinct = 0;
+        let total = 0;
+        for (const t of terms) {
+          let idx = low.indexOf(t);
+          if (idx === -1) continue;
+          distinct++;
+          let occ = 0;
+          while (idx !== -1 && occ < 3) { occ++; idx = low.indexOf(t, idx + t.length); }
+          total += occ;
+        }
+        if (distinct < 1) continue;
+        const score = distinct * 10 + Math.min(total - distinct, 5);
+        if (score < minScore) continue;
+        hits.push({ dir: p.dir, section, lineno: i + 1, text: trimmed, score });
+      }
+    }
+  }
+  hits.sort((a, b) => b.score - a.score
+    || a.dir.localeCompare(b.dir)
+    || SECTIONS.indexOf(a.section) - SECTIONS.indexOf(b.section)
+    || a.lineno - b.lineno);
+  return hits.slice(0, Math.max(1, Math.min(50, k)));
+}
+
 module.exports = {
   PACKS_DIR, SECTIONS, slugify,
   listPacks, findPack, readPack, writePack, createPack, updatePack, removePack, isNearDupJournal,
   listSkillPacks, setSkill, listAbilities, setKind, parentByPrefix, setParent, recordApplied, recordCoUse,
-  touchUsed, packNameFromPath, matchPacks, reindex, markIndexDirty,
+  touchUsed, packNameFromPath, matchPacks, searchLines, reindex, markIndexDirty,
   archivePack, restorePack, listArchived,
   readProvenance, provenanceOf, setProvenance, recordForegroundWrite,
 };

package/core/recall/discoverer.js

@@ -217,14 +217,18 @@ function excerptFor(id, packsLib, entitiesLib) {
 }
 
 const WALKER_SYSTEM = [
-  "You are the recall walker for an assistant's long-term memory.",
+  "You are the recall ROUTER for an assistant's long-term memory.",
   "You are given the user's message, recent conversation, and candidate memory nodes (some matched by keyword, some pulled in by graph links).",
-  "Decide which nodes are GENUINELY relevant to what the user is doing now.",
+  "Your job is to route: decide which nodes GENUINELY bear on what the user is doing now, and how strongly.",
+  "You are a router, NOT a summarizer: never paraphrase, rewrite, or invent the contents of a node. The verbatim fact will be surfaced separately; your why is only a pointer to WHY the node is relevant.",
   "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.',
+  "For each kept node give three fields:",
+  "  - id: the candidate's id, verbatim.",
+  "  - why: a terse pointer (≤12 words) to why it's relevant — quote a concrete anchor verbatim, never a paraphrase of the whole node.",
+  "  - score: an integer 0–100 for how strongly this node bears on THIS message. 100 = the message is directly about it; 60 = plausibly useful; below 50 = weak/incidental.",
+  'Reply with ONLY a JSON array: [{"id":"pack:foo","why":"shared lime theme governs this app","score":85}]. Use [] if none.',
 ].join("\n");
 
 // Run the walker model on the prompt. Prefer the warm (reused) process for
@@ -276,7 +280,7 @@ async function runWalker(prompt, options = {}) {
       items: {
         type: "object",
         required: ["id"],
-        properties: { id: { type: "string" }, why: { type: "string" } },
+        properties: { id: { type: "string" }, why: { type: "string" }, score: { type: "number" } },
       },
     },
     timeoutMs: WALKER_TIMEOUT_MS,
@@ -291,11 +295,47 @@ async function runWalker(prompt, options = {}) {
   };
 }
 
-// Judge candidates. Returns { kept: Map|null, costUsd, source, walkerMs } —
-// kept null means fail-open (walker off/failed/unparseable).
+// A walker score is an integer 0–100. Missing/garbage → 60: a neutral pass so
+// a parse hiccup never silently buries a node the walker meant to keep.
+function clampScore(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return 60;
+  return Math.max(0, Math.min(100, Math.round(n)));
+}
+
+// WS5: which co-kept pairs earn a weak warming bump. Co-KEPT (walker co-injected
+// them this turn) is noisier than co-OPEN (the model actually opened them), so
+// it warms only under three guards: both endpoints scored ≥ minScore (high-
+// confidence keeps), the pair contains ≥1 message-grounded (user-origin) seed —
+// never let two pure graph hops reinforce each other into a phantom edge — and
+// only the top `maxPairs` strongest pairs warm. Pack/entity graph nodes only
+// (tools and episodes are not graph nodes). Pure + deterministic, so it is
+// unit-tested without touching the graph. Returns [[a, b], ...].
+function cokeptPairs(keptIds, scoreById, groundedIds, { minScore = 60, maxPairs = 3 } = {}) {
+  if (!scoreById || !(scoreById.size >= 0)) return [];
+  const grounded = groundedIds instanceof Set ? groundedIds : new Set(groundedIds || []);
+  const eligible = [...keptIds].filter((id) =>
+    (id.startsWith("pack:") || id.startsWith("entity:")) &&
+    scoreById.has(id) && scoreById.get(id) >= minScore);
+  const pairs = [];
+  for (let i = 0; i < eligible.length; i++) {
+    for (let j = i + 1; j < eligible.length; j++) {
+      const a = eligible[i], b = eligible[j];
+      if (!grounded.has(a) && !grounded.has(b)) continue; // ≥1 message-grounded endpoint
+      pairs.push({ a, b, strength: scoreById.get(a) + scoreById.get(b) });
+    }
+  }
+  pairs.sort((x, y) => y.strength - x.strength || (x.a + "" + x.b).localeCompare(y.a + "" + y.b));
+  return pairs.slice(0, Math.max(0, maxPairs)).map((p) => [p.a, p.b]);
+}
+
+// Judge candidates. Returns { kept: Map|null, scores: Map|null, costUsd, source,
+// walkerMs } — kept/scores null means fail-open (walker off/failed/unparseable).
+// kept is id→why(string); scores is the parallel id→0-100 relevance from the
+// router, consumed by the injection score-gate and asymmetric warming.
 async function walk(userText, contextText, candidates, options = {}) {
   if (!WALKER_ENABLED || candidates.length === 0) {
-    return { kept: null, costUsd: null, source: "off", walkerMs: 0, provider: options.provider || null, model: null };
+    return { kept: null, scores: null, costUsd: null, source: "off", walkerMs: 0, provider: options.provider || null, model: null };
   }
   const lines = candidates.map((c) => {
     const tag = c.activated ? ` [linked via ${c.via || "graph"}]` : "";
@@ -309,26 +349,28 @@ async function walk(userText, contextText, candidates, options = {}) {
     "Candidate memory nodes:",
     ...lines,
     "",
-    'Reply ONLY with the JSON array of kept nodes and their why, e.g. [{"id":"' + candidates[0].id + '","why":"..."}].',
+    'Reply ONLY with the JSON array of kept nodes, each with id, why, and score (0–100), e.g. [{"id":"' + candidates[0].id + '","why":"...","score":80}].',
   ].join("\n");
   const t0 = Date.now();
   try {
     const { text, costUsd, source, provider, model } = await runWalker(prompt, options);
     const walkerMs = Date.now() - t0;
     const match = String(text || "").match(/\[[\s\S]*\]/);
-    if (!match) return { kept: null, costUsd, source, walkerMs, provider, model };
+    if (!match) return { kept: null, scores: null, costUsd, source, walkerMs, provider, model };
     const arr = JSON.parse(match[0]);
-    if (!Array.isArray(arr)) return { kept: null, costUsd, source, walkerMs, provider, model };
+    if (!Array.isArray(arr)) return { kept: null, scores: null, costUsd, source, walkerMs, provider, model };
     const known = new Set(candidates.map((c) => c.id));
     const out = new Map();
+    const scores = new Map();
     for (const item of arr) {
       if (item && typeof item.id === "string" && known.has(item.id)) {
         out.set(item.id, String(item.why || "").slice(0, 120));
+        scores.set(item.id, clampScore(item.score));
       }
     }
-    return { kept: out, costUsd, source, walkerMs, provider, model };
+    return { kept: out, scores, costUsd, source, walkerMs, provider, model };
   } catch (e) {
-    return { kept: null, costUsd: null, source: "failed", walkerMs: Date.now() - t0, provider: options.provider || null, model: null };
+    return { kept: null, scores: null, costUsd: null, source: "failed", walkerMs: Date.now() - t0, provider: options.provider || null, model: null };
   }
 }
 
@@ -491,6 +533,14 @@ async function run(ctx) {
   // 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";
+  // Score-gate config (WS4). When a relevance floor is set, the walker's real
+  // per-turn score decides injection — so the cascade must NOT auto-KEEP from
+  // history: a sticky pack's history score is always high and would re-leak the
+  // very irrelevant-recall defect the gate exists to fix. Auto-DROP still fires
+  // (dead nodes cost tokens and never help); would-be-keeps are routed to the
+  // judge instead, where they earn a real current-turn score and face the gate.
+  const minScore = tier === "full" ? tuning.get("minRelevanceScore") : 0;
+  const gateConfigured = minScore > 0;
   const autoKept = new Map(); // id -> canned why (honest provenance)
   const autoDropped = [];
   const shadowVerdicts = new Map(); // id -> auto verdict, also sent to judge
@@ -505,13 +555,16 @@ async function run(ctx) {
       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);
+      if (v === "keep") {
+        if (gateConfigured) { judgeCands.push(c); continue; } // no history auto-keep under the gate — the judge scores it
+        autoKept.set(c.id, `kept ${st.kept}/${st.seen} recent similar turns`);
+      } else autoDropped.push(c.id);
     }
   }
 
-  const walkRes = await walk(userText, contextText || fullContext, judgeCands, { provider: provider || null });
+  const walkRes = await walk(userText, contextText || fullContext, judgeCands, { provider: provider || null, ...(ctx.walkerOptions || {}) });
   const whyById = walkRes.kept;
+  const scoreById = walkRes.scores; // parallel id→0-100 router relevance (null on fail-open)
 
   let shadowChecks = 0, shadowAgree = 0;
   if (whyById && shadowVerdicts.size) {
@@ -529,6 +582,19 @@ async function run(ctx) {
   // 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;
+  // Score-gate on injection (WS4 keystone): drop any walker-kept node scoring
+  // below the relevance floor, so a weakly-linked node no longer gets injected.
+  // Only fires when the walker produced real scores (full tier, successful walk);
+  // fail-open (scores null) skips the gate. A successful walk that gates every
+  // node leaves an empty (non-null) whyMap → inject nothing, which is the
+  // correct signal "nothing was relevant" (NOT the fail-open seed fallback,
+  // which is reserved for a walk that never produced a verdict at all).
+  const gatedOut = [];
+  if (whyMap && gateConfigured && scoreById) {
+    for (const id of [...whyMap.keys()]) {
+      if (scoreById.has(id) && scoreById.get(id) < minScore) { whyMap.delete(id); gatedOut.push(id); }
+    }
+  }
   if (whyMap) for (const [id, why] of autoKept) whyMap.set(id, why);
   let keptIds;
   if (whyMap) {
@@ -570,8 +636,23 @@ async function run(ctx) {
   const finalPacks = packMatches.slice(0, packLimit);
   const finalEnts = entityMatches.slice(0, 4);
 
-  // 5: render via shared builders, then weave in the why-bullets.
-  let packBlock = buildPackBlock(finalPacks, budget);
+  // 5: render via shared builders, then weave in the why-bullets. Extractive
+  // mode (default on) surfaces the verbatim lines that matched this message from
+  // anywhere in each pack — the router already scored relevance; here we hand
+  // the model the actual facts, not just a Stance headline (Defect-A fix). Line
+  // hits come from the WS1 per-line search, scoped per final pack.
+  const extractiveOn = tuning.get("extractive") !== "off" && typeof packsLib.searchLines === "function";
+  let matchedLines = null;
+  if (extractiveOn && finalPacks.length) {
+    matchedLines = new Map();
+    for (const m of finalPacks) {
+      try {
+        const hits = packsLib.searchLines(userText, { dir: m.dir, k: 8 });
+        if (hits && hits.length) matchedLines.set(m.dir, hits);
+      } catch (e) { /* a pack with no line hits just shows Stance */ }
+    }
+  }
+  let packBlock = buildPackBlock(finalPacks, budget, extractiveOn ? { extractive: true, matchedLines } : {});
   const entityBlock = buildEntityBlock(finalEnts, budget);
   if (packBlock && whyMap) {
     const bullets = finalPacks
@@ -631,6 +712,25 @@ async function run(ctx) {
     episodeBlock = `\n\n## Past work that looks related\nFrom earlier conversations — verify before relying on it:\n${lines.join("\n")}\n`;
   }
 
+  // WS5: asymmetric co-kept warming (dark-launch OFF). Feed a weak Hebbian
+  // signal from the walker's co-injected, high-confidence, message-grounded
+  // keeps — a fraction of a real co-use bump. Best-effort: never breaks recall.
+  let cokeptWarmed = [];
+  if (tier === "full" && tuning.get("cokeptWarming") === "on" && scoreById && keptIds.size > 1) {
+    try {
+      const grounded = new Set([
+        ...packSeeds.filter((m) => m.origin === "user").map((m) => `pack:${m.dir}`),
+        ...entSeeds.filter((m) => m.origin === "user").map((m) => `entity:${m.slug}`),
+      ]);
+      cokeptWarmed = cokeptPairs(keptIds, scoreById, grounded, {
+        minScore: tuning.get("warmMinScore"),
+        maxPairs: tuning.get("cokeptMaxPairs"),
+      });
+      const amount = tuning.get("cokeptAmount");
+      for (const [a, b] of cokeptWarmed) graph.reinforce(a, b, amount);
+    } catch (e) { cokeptWarmed = []; }
+  }
+
   metrics.logTurn({
     engine: "discoverer",
     provider: walkRes.provider || provider || "",
@@ -640,10 +740,13 @@ async function run(ctx) {
     seeds: seedNodes,
     activated: [...activated.entries()].map(([id, a]) => ({ id, activation: a.activation, hop: a.hop })),
     cand: candidates.map((c) => ({ id: c.id, act: !!c.activated })),
-    kept: [...keptIds].map((id) => ({ id, why: whyMap ? whyMap.get(id) : "" })),
+    kept: [...keptIds].map((id) => ({ id, why: whyMap ? whyMap.get(id) : "", score: scoreById && scoreById.has(id) ? scoreById.get(id) : null })),
     auto: (autoKept.size || autoDropped.length || shadowChecks)
       ? { kept: [...autoKept.keys()], dropped: autoDropped, shadow: { checks: shadowChecks, agree: shadowAgree } }
       : null,
+    gate: gateConfigured ? { min: minScore, out: gatedOut } : undefined,
+    extracted: matchedLines && matchedLines.size ? [...matchedLines].map(([dir, hits]) => ({ dir, n: hits.length })) : undefined,
+    warmed: cokeptWarmed.length ? cokeptWarmed : undefined,
     gated: false,
     latencyMs: Date.now() - started,
     seedMs,
@@ -660,4 +763,4 @@ async function run(ctx) {
   };
 }
 
-module.exports = { name: "discoverer", run, runWalker, needsRecall, recallTier, walk, cascadeVerdict, scoutToolGaps, renderToolGaps, episodesAllowedForSpeaker };
+module.exports = { name: "discoverer", run, runWalker, needsRecall, recallTier, walk, cascadeVerdict, cokeptPairs, scoutToolGaps, renderToolGaps, episodesAllowedForSpeaker };

package/core/recall/kpi.js

@@ -16,6 +16,9 @@ function emptyBucket(v) {
     rescueTurns: 0, rescues: 0, walkerFailed: 0,
     latencyMsTotal: 0, costUsd: 0, autoKept: 0, autoDropped: 0,
     opens: 0, reviewerUses: 0, byTier: {},
+    // Pass-4 signals (WS0): walker relevance scores on kept nodes, score-gate
+    // activity, and co-kept warmings — the ruler for the accuracy/precision work.
+    keptScoreSum: 0, keptScoreN: 0, gateActiveTurns: 0, gateFiredTurns: 0, gatedNodes: 0, warmings: 0,
   };
 }
 
@@ -54,6 +57,14 @@ function scanLog() {
     const seedIds = new Set((rec.seeds || []).map((s) => s.id));
     const rescues = kept.filter((k) => !seedIds.has(k.id)).length;
     if (rescues > 0) { b.rescueTurns++; b.rescues += rescues; }
+    for (const k of kept) if (typeof k.score === "number") { b.keptScoreSum += k.score; b.keptScoreN++; }
+    if (rec.gate) {
+      b.gateActiveTurns++;
+      const out = (rec.gate.out || []).length;
+      b.gatedNodes += out;
+      if (out > 0) b.gateFiredTurns++;
+    }
+    if (Array.isArray(rec.warmed)) b.warmings += rec.warmed.length;
     if (rec.auto) {
       b.autoKept += (rec.auto.kept || []).length;
       b.autoDropped += (rec.auto.dropped || []).length;
@@ -91,6 +102,10 @@ function aggregate() {
       walkerFailPct: pct(b.walkerFailed, b.turns - b.gated),
       autoKept: b.autoKept,
       autoDropped: b.autoDropped,
+      avgKeptScore: b.keptScoreN ? Math.round(b.keptScoreSum / b.keptScoreN) : null,
+      gatedNodes: b.gatedNodes,
+      gateFiredPct: pct(b.gateFiredTurns, b.gateActiveTurns),
+      warmings: b.warmings,
     });
   }
   rows.sort((a, b) => (a.from || "").localeCompare(b.from || ""));
@@ -107,6 +122,9 @@ function renderTable(rows) {
     ["turns", (r) => String(r.turns)],
     ["rescue", (r) => (r.rescuePct == null ? "—" : r.rescuePct + "%")],
     ["noise", (r) => (r.noisePct == null ? "—" : r.noisePct + "%")],
+    ["relevance", (r) => (r.avgKeptScore == null ? "—" : String(r.avgKeptScore))],
+    ["gate", (r) => (r.gateFiredPct == null ? "—" : `${r.gateFiredPct}% / ${r.gatedNodes}`)],
+    ["warm", (r) => String(r.warmings || 0)],
     ["avg", (r) => (r.avgLatencyMs / 1000).toFixed(1) + "s"],
     ["gated", (r) => (r.gatedPct == null ? "—" : r.gatedPct + "%")],
     ["$ / turn", (r) => "$" + r.costPerTurnUsd.toFixed(3)],
@@ -177,6 +195,8 @@ function htmlReport() {
     barChart("Average recall latency", rows.map((r) => ({ label: label(r), value: r.avgLatencyMs / 1000 })), { fmt: (v) => v.toFixed(1) + "s" }),
     barChart("Recall cost per turn", rows.map((r) => ({ label: label(r), value: r.costPerTurnUsd })), { fmt: (v) => "$" + v.toFixed(3) }),
     barChart("Gated turns — pleasantries skipped for free", rows.map((r) => ({ label: label(r), value: r.gatedPct })), { fmt: (v) => Math.round(v) + "%", max: 100 }),
+    barChart("Average relevance of kept memories — walker score 0–100 (higher = the model kept more clearly-relevant nodes)",
+      rows.map((r) => ({ label: label(r), value: r.avgKeptScore })), { fmt: (v) => Math.round(v), max: 100 }),
     barChart("Walker failure rate", rows.map((r) => ({ label: label(r), value: r.walkerFailPct })), { fmt: (v) => Math.round(v) + "%", max: 100 }),
   ].filter(Boolean).map((s) => `<div class="card">${s}</div>`).join("\n");
 
@@ -191,8 +211,9 @@ function htmlReport() {
 
   const tierRows = rows.map((r) => {
     const t = Object.entries(r.byTier).map(([k, v]) => `${k}: ${v.turns}× @ ${(v.avgMs / 1000).toFixed(1)}s`).join(" · ") || "—";
+    const rel = `${r.avgKeptScore == null ? "—" : r.avgKeptScore} / ${r.gateFiredPct == null ? "—" : r.gateFiredPct + "%·" + r.gatedNodes} / ${r.warmings || 0}`;
     return `<tr><td>${esc(r.v)}</td><td>${esc(r.from)}→${esc(r.to)}</td><td>${r.turns}</td><td>${t}</td>` +
-      `<td>${r.opens} / ${r.reviewerUses}</td><td>${r.autoKept} / ${r.autoDropped}</td><td>${esc(r.models.join(", ") || "—")}</td></tr>`;
+      `<td>${r.opens} / ${r.reviewerUses}</td><td>${r.autoKept} / ${r.autoDropped}</td><td>${esc(rel)}</td><td>${esc(r.models.join(", ") || "—")}</td></tr>`;
   }).join("\n");
 
   return `<!doctype html>
@@ -212,7 +233,7 @@ th{color:#8b98a5;font-weight:600}
 ${charts}
 ${trendChart ? `<div class="card">${trendChart}</div>` : ""}
 <div class="card"><table>
-<tr><th>version</th><th>window</th><th>turns</th><th>latency by tier</th><th>opens / reviewer</th><th>cascade kept / dropped</th><th>walker model</th></tr>
+<tr><th>version</th><th>window</th><th>turns</th><th>latency by tier</th><th>opens / reviewer</th><th>cascade kept / dropped</th><th>relevance / gate·nodes / warm</th><th>walker model</th></tr>
 ${tierRows}
 </table></div>
 </body></html>`;

package/core/recall/tuning.js

@@ -18,6 +18,24 @@ const KNOBS = {
   seedsTierMaxWords: { def: 4, min: 2, max: 6, env: "RECALL_SEEDS_TIER_MAX_WORDS" },
   decayHalfLifeDays: { def: 60, min: 10, max: 90, env: "RECALL_DECAY_HALF_LIFE_DAYS" },
   cascade: { def: "on", values: ["on", "off"], env: "RECALL_CASCADE" },
+  // Extractive on-open injection: surface Stance verbatim + the actual lines
+  // that matched this message (from anywhere in the pack), not just a headline.
+  extractive: { def: "on", values: ["on", "off"], env: "RECALL_EXTRACTIVE" },
+  // Injection score-gate (keystone): a walker-kept node scoring below this floor
+  // (0–100) is not injected. Set 0 to disable the gate entirely (and restore
+  // history-based cascade auto-keep). Default 55 = drop weak/incidental links.
+  minRelevanceScore: { def: 55, min: 0, max: 100, env: "RECALL_MIN_RELEVANCE_SCORE" },
+  // Asymmetric co-kept warming (WS5). Co-OPEN (the model actually opened the
+  // nodes) warms at full strength; co-KEPT (the walker co-injected them) is a
+  // weaker, noisier signal. Dark-launched OFF: it writes persistent graph state,
+  // so it can't be validated in a single test session — flip it on deliberately.
+  cokeptWarming: { def: "off", values: ["on", "off"], env: "RECALL_COKEPT_WARMING" },
+  // How much a co-kept pair bumps its `related` edge (vs 1.0 for a real co-use).
+  cokeptAmount: { def: 0.15, min: 0, max: 1, env: "RECALL_COKEPT_AMOUNT" },
+  // Only co-kept nodes scoring at/above this floor warm — high-confidence keeps.
+  warmMinScore: { def: 60, min: 0, max: 100, env: "RECALL_WARM_MIN_SCORE" },
+  // Cap on how many (strongest) co-kept pairs warm per turn.
+  cokeptMaxPairs: { def: 3, min: 1, max: 10, env: "RECALL_COKEPT_MAX_PAIRS" },
 };
 
 let _cache = null;

package/core/runner.js

@@ -1560,8 +1560,11 @@ async function finalizeStreamPreview(state, result) {
       if (buffer) await editMessage(id, buffer.slice(-4000), telegramHtmlOpts({ streaming: true }));
       return;
     }
+    // Verbose OFF: the narration ("Let me…") is transient progress only — delete
+    // the preview so settled chat carries just the final answer. Verbose ON keeps
+    // the narration trail. Either way the live preview still showed progress mid-run.
     const narration = String(result.narrationText || "").trim();
-    if (narration) await editMessage(id, narration.slice(-4000), telegramHtmlOpts({ streaming: true }));
+    if (narration && state.settings?.showThinking) await editMessage(id, narration.slice(-4000), telegramHtmlOpts({ streaming: true }));
     else await deleteMessage(id);
   } catch (_) { /* preview cleanup is best-effort; the final answer still goes out */ }
 }

package/core/system-prompt.js

@@ -471,6 +471,7 @@ function buildDynamicContextBlock(opts = {}) {
 const packsInjectedFor = new Map(); // `${adapterId}:${channelId}:${dir}` -> `${sessionId}:${updated}`
 const PACK_INJECT_MAX_CHARS = 4000;
 const DEFAULT_MEMORY_RECALL_MAX_CHARS = 9000;
+const EXTRACTIVE_LINES_PER_SECTION = 4;
 
 // Progressive disclosure: when on, a matched pack is injected as a cheap
 // teaser (Stance + State + a pointer) rather than its full body. Heavy
@@ -539,6 +540,7 @@ function consumeLastInjected() {
 }
 
 function formatPackForContext(pack, packsLib, opts = {}) {
+  const extractive = !!opts.extractive;
   const headline = !!opts.headline;
   const progressive = !!opts.progressive;
   const clip = (s, n) => (s.length > n ? s.slice(0, n) + "\n…[truncated — read the full pack file]" : s);
@@ -553,30 +555,61 @@ function formatPackForContext(pack, packsLib, opts = {}) {
     const childLines = children.map((c) => `- ${c.dir}: ${c.description || c.name}`).join("\n");
     parts.push(`Sub-packs (dig deeper with \`open-claudia pack show <dir>\`):\n${childLines}`);
   }
-  // Progressive mode injects only the live sections (Stance = how to think,
-  // State = where we are) plus a pointer; full mode also inlines Procedure
-  // and the recent Journal.
-  // Headline = description + Stance only (Stance carries hard rules/prefs that
-  // must always apply when the topic comes up). Everything else is pulled on
-  // demand. Progressive = Stance + State. Full = Stance + Procedure + State.
-  const sections = headline
-    ? ["Stance"]
-    : progressive
-    ? ["Stance", "State"]
-    : ["Stance", "Procedure", "State"];
-  for (const section of sections) {
-    const body = (pack.sections[section] || "").trim();
-    if (body) parts.push(`#### ${section}\n${body}`);
-  }
-  if (headline) {
-    const hidden = ["State", "Procedure", "Journal"].filter((s) => (pack.sections[s] || "").trim());
-    if (hidden.length) parts.push(`#### More\n${hidden.join(" + ")} not shown — run \`open-claudia pack show ${pack.dir}\` to read them.`);
-  } else if (progressive) {
-    const hasMore = (pack.sections.Procedure || "").trim() || (pack.sections.Journal || "").trim();
-    if (hasMore) parts.push(`#### More\nProcedure + Journal not shown — run \`open-claudia pack show ${pack.dir}\` to read them.`);
+  // Extractive mode (Defect-A fix): the old headline showed Stance only, so a
+  // fact living in State/Procedure/Journal never loaded even when it was the
+  // whole reason the pack matched. Here we surface Stance verbatim (it carries
+  // the always-on rules/prefs) PLUS the actual lines from anywhere in the pack
+  // that fuzzy-matched this message, tagged by section — verbatim, never a
+  // paraphrase. Progressive/headline/full below are the pre-extractive modes,
+  // still used by the classic engine and as the fallback when no lines matched.
+  if (extractive) {
+    const stance = (pack.sections.Stance || "").trim();
+    if (stance) parts.push(`#### Stance\n${stance}`);
+    const stanceLow = stance.toLowerCase();
+    const bySection = new Map();
+    for (const h of (Array.isArray(opts.matchedLines) ? opts.matchedLines : [])) {
+      if (!h || h.section === "Stance") continue; // Stance already shown in full
+      const text = String(h.text || "").trim();
+      if (!text) continue;
+      if (stanceLow && stanceLow.includes(text.toLowerCase())) continue; // dedupe vs Stance
+      if (!bySection.has(h.section)) bySection.set(h.section, []);
+      const arr = bySection.get(h.section);
+      if (arr.length < EXTRACTIVE_LINES_PER_SECTION && !arr.includes(text)) arr.push(text);
+    }
+    let matchedAny = false;
+    for (const section of ["Procedure", "State", "Journal"]) {
+      const arr = bySection.get(section);
+      if (!arr || !arr.length) continue;
+      matchedAny = true;
+      parts.push(`#### ${section} (matched)\n${arr.map((t) => (/^\s*[-*]/.test(t) ? t : `- ${t}`)).join("\n")}`);
+    }
+    parts.push(`#### More\n${matchedAny ? "Showing Stance + the lines matched to this message." : "Showing Stance."} Full pack (State/Procedure/Journal): \`open-claudia pack show ${pack.dir}\`.`);
   } else {
-    const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-10).join("\n");
-    if (journal) parts.push(`#### Journal (recent)\n${journal}`);
+    // Progressive mode injects only the live sections (Stance = how to think,
+    // State = where we are) plus a pointer; full mode also inlines Procedure
+    // and the recent Journal.
+    // Headline = description + Stance only (Stance carries hard rules/prefs that
+    // must always apply when the topic comes up). Everything else is pulled on
+    // demand. Progressive = Stance + State. Full = Stance + Procedure + State.
+    const sections = headline
+      ? ["Stance"]
+      : progressive
+      ? ["Stance", "State"]
+      : ["Stance", "Procedure", "State"];
+    for (const section of sections) {
+      const body = (pack.sections[section] || "").trim();
+      if (body) parts.push(`#### ${section}\n${body}`);
+    }
+    if (headline) {
+      const hidden = ["State", "Procedure", "Journal"].filter((s) => (pack.sections[s] || "").trim());
+      if (hidden.length) parts.push(`#### More\n${hidden.join(" + ")} not shown — run \`open-claudia pack show ${pack.dir}\` to read them.`);
+    } else if (progressive) {
+      const hasMore = (pack.sections.Procedure || "").trim() || (pack.sections.Journal || "").trim();
+      if (hasMore) parts.push(`#### More\nProcedure + Journal not shown — run \`open-claudia pack show ${pack.dir}\` to read them.`);
+    } else {
+      const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-10).join("\n");
+      if (journal) parts.push(`#### Journal (recent)\n${journal}`);
+    }
   }
   // Pack↔tool usages: concrete reusable-tool invocations recorded while this
   // pack was active, so the agent sees HOW a tool was used in this topic (not
@@ -603,7 +636,9 @@ function buildPackBlock(matches, budget, opts = {}) {
     const channelId = currentChannelId();
     const runIdentity = promptDedupeIdentity(opts);
     const progressive = packProgressive();
+    const extractive = opts.extractive === true;
     const headline = recallHeadline();
+    const matchedByDir = opts.matchedLines instanceof Map ? opts.matchedLines : new Map();
     const collector = opts.recallCollector || lastInjected;
     const blocks = [];
     const used = [];
@@ -619,7 +654,7 @@ function buildPackBlock(matches, budget, opts = {}) {
       // as the task tree), so the pack survives compaction without paying
       // to re-stamp an anchor on every intervening turn.
       if (packsInjectedFor.get(key) === stamp) continue;
-      const block = formatPackForContext(pack, packsLib, { progressive, headline });
+      const block = formatPackForContext(pack, packsLib, { progressive, headline, extractive, matchedLines: extractive ? (matchedByDir.get(m.dir) || []) : undefined });
       if (!tryUseRecallBudget(budget, block)) continue;
       packsInjectedFor.set(key, stamp);
       collector.packs.push(pack.name || m.dir);
@@ -627,7 +662,9 @@ function buildPackBlock(matches, budget, opts = {}) {
     }
     if (used.length > 0) setImmediate(() => { try { packsLib.touchUsed(used); } catch (e) {} });
     if (blocks.length === 0) return "";
-    const intro = headline
+    const intro = extractive
+      ? `Long-term topic context auto-matched to this message. Each pack shows its Stance (always-on rules/prefs) plus the specific lines that matched — verbatim, not a summary. These are facts already recalled for you; pull the full State/Procedure/Journal with \`open-claudia pack show <dir>\` when you need more. If the user asked for a skill by name, \`pack show\` the matching pack to load its Procedure. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.`
+      : headline
       ? `Long-term topic context auto-matched to this message — these are *headlines* (description + Stance only), not full packs. Decide which are actually relevant and pull the full State/Procedure/Journal on demand with \`open-claudia pack show <dir>\`. If the user asked for a skill by name, \`pack show\` the matching pack to load its Procedure. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.`
       : `Long-term topic context auto-matched to this message. If the user asked for a skill by name, treat the matching pack's Procedure section as that Open Claudia skill. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.`;
     return `\n\n## Active Open Claudia skills / context packs\n${intro}\n\n${blocks.join("\n\n---\n\n")}`;
@@ -974,8 +1011,8 @@ async function buildOptionalRecallContext(prompt, opts = {}) {
       { provider: recallProvider },
     ),
     logRecall,
-    buildPackBlock: (matches, recallBudget) => buildPackBlock(matches, recallBudget, recallOpts),
-    buildEntityBlock: (matches, recallBudget) => buildEntityBlock(matches, recallBudget, recallOpts),
+    buildPackBlock: (matches, recallBudget, engineOpts) => buildPackBlock(matches, recallBudget, { ...recallOpts, ...(engineOpts || {}) }),
+    buildEntityBlock: (matches, recallBudget, engineOpts) => buildEntityBlock(matches, recallBudget, { ...recallOpts, ...(engineOpts || {}) }),
   };
   const result = await engine.run({
     userText, contextText, fullContext, packLimit, budget, helpers, provider: recallProvider,
@@ -1129,6 +1166,7 @@ module.exports = {
   PromptConstructionError,
   buildCoreInstructions,
   buildOptionalRecallContext,
+  formatPackForContext,
   buildDynamicContextBlock,
   buildExternalModeBlock,
   buildSpacesTaskModeBlock,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.37",
+  "version": "3.0.41",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {
@@ -10,7 +10,7 @@
     "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-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",
-    "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-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-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"
+    "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": [
     "bot.js",
@@ -38,6 +38,9 @@
     "test-recall-engine.js",
     "test-recall-graph.js",
     "test-recall-discoverer.js",
+    "test-walker-score.js",
+    "test-score-gate.js",
+    "test-cokept-warming.js",
     "test-project-transcripts-smoke.js",
     "test-abilities.js",
     "test-ability-extraction.js",
@@ -47,6 +50,8 @@
     "test-ability-merge-guard.js",
     "test-learning-e2e.js",
     "test-pack-nesting.js",
+    "test-pack-search.js",
+    "test-extractive-injection.js",
     "test-read-signal.js",
     "test-tools.js",
     "test-tool-graph.js",

package/test-cokept-warming.js

@@ -0,0 +1,117 @@
+// WS5: asymmetric co-kept warming. Co-OPEN warming (the model actually opened
+// the nodes together) fires at full strength elsewhere; co-KEPT (the walker
+// co-injected them) is a weaker, noisier signal, so it warms by a small amount
+// and only under guards — both endpoints high-confidence (score ≥ warmMinScore),
+// ≥1 message-grounded (user-origin) endpoint, and only the top N pairs. The
+// feature is dark-launched OFF (it writes persistent graph state, so it can't be
+// validated inside one test session). This test covers the pure pair-selection
+// (cokeptPairs) and the end-to-end warming write through disc.run() when ON.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-warm-"));
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+process.env.RECALL_DISCOVERER_WALKER = "on";
+process.env.RECALL_METRICS = "off";
+process.env.TOOLS_DIR = path.join(tmp, "tools");
+process.env.RECALL_CASCADE = "off";
+delete process.env.RECALL_MIN_RELEVANCE_SCORE; // default gate (55) — 80/70 both survive
+delete process.env.RECALL_COKEPT_WARMING; // default OFF unless a case flips it
+
+const disc = require("./core/recall/discoverer");
+const graph = require("./core/recall/graph");
+
+// ── pure: cokeptPairs guards + ranking ───────────────────────────────────────
+const S = (obj) => new Map(Object.entries(obj));
+
+// basic: a high-score grounded pair is warmed
+assert.deepStrictEqual(
+  disc.cokeptPairs(new Set(["pack:a", "pack:b"]), S({ "pack:a": 80, "pack:b": 70 }), new Set(["pack:a"]), { minScore: 60, maxPairs: 3 }),
+  [["pack:a", "pack:b"]], "grounded high-score pair warms");
+
+// grounding guard: neither endpoint is a message-grounded seed → no warming
+assert.deepStrictEqual(
+  disc.cokeptPairs(new Set(["pack:a", "pack:b"]), S({ "pack:a": 90, "pack:b": 90 }), new Set(), { minScore: 60, maxPairs: 3 }),
+  [], "two pure graph hops never reinforce each other (no grounded endpoint)");
+
+// score guard: an endpoint below the floor is dropped, killing the only pair
+assert.deepStrictEqual(
+  disc.cokeptPairs(new Set(["pack:a", "pack:b"]), S({ "pack:a": 80, "pack:b": 50 }), new Set(["pack:a"]), { minScore: 60, maxPairs: 3 }),
+  [], "a below-floor endpoint removes the pair");
+
+// node-type guard: only pack/entity graph nodes count — tools/episodes are not graph nodes
+assert.deepStrictEqual(
+  disc.cokeptPairs(new Set(["pack:a", "tool:t", "episode:e"]), S({ "pack:a": 90, "tool:t": 90, "episode:e": 90 }), new Set(["pack:a"]), { minScore: 60, maxPairs: 3 }),
+  [], "tools and episodes are excluded from co-kept warming");
+
+// entity nodes are eligible too
+assert.deepStrictEqual(
+  disc.cokeptPairs(new Set(["entity:e1", "pack:a"]), S({ "entity:e1": 70, "pack:a": 65 }), new Set(["entity:e1"]), { minScore: 60, maxPairs: 3 }),
+  [["entity:e1", "pack:a"]], "entity↔pack pair warms when grounded + high-score");
+
+// cap + ranking: strongest pairs first, capped at maxPairs
+const three = disc.cokeptPairs(
+  new Set(["pack:a", "pack:b", "pack:c"]),
+  S({ "pack:a": 90, "pack:b": 80, "pack:c": 70 }),
+  new Set(["pack:a", "pack:b", "pack:c"]), { minScore: 60, maxPairs: 2 });
+assert.deepStrictEqual(three, [["pack:a", "pack:b"], ["pack:a", "pack:c"]], "top-2 strongest pairs by combined score");
+const one = disc.cokeptPairs(
+  new Set(["pack:a", "pack:b", "pack:c"]),
+  S({ "pack:a": 90, "pack:b": 80, "pack:c": 70 }),
+  new Set(["pack:a"]), { minScore: 60, maxPairs: 1 });
+assert.deepStrictEqual(one, [["pack:a", "pack:b"]], "maxPairs=1 keeps only the single strongest pair");
+
+// ── integration: warming ON writes a reinforced edge; OFF writes none ─────────
+const packs = {
+  alpha: { dir: "alpha", name: "Alpha", description: "alpha pack", parent: null, tags: [], sections: { Stance: "alpha stance", Procedure: "", State: "", Journal: "" } },
+  beta: { dir: "beta", name: "Beta", description: "beta pack", parent: null, tags: [], sections: { Stance: "beta stance", Procedure: "", State: "", Journal: "" } },
+};
+const packsLib = {
+  matchPacks: (text) => /widget/.test(text) ? [{ dir: "alpha", name: "Alpha", score: 5 }, { dir: "beta", name: "Beta", score: 4 }] : [],
+  readPack: (dir) => packs[dir] || null,
+  listPacks: () => Object.values(packs),
+  searchLines: () => [],
+  PACKS_DIR: tmp,
+};
+const entitiesLib = { matchEntities: () => [], readEntity: () => null, listEntities: () => [], ENTITIES_DIR: tmp };
+const mergeMatches = (primary, secondary, keyOf) => {
+  const out = primary.map((m) => ({ ...m, origin: "user" }));
+  const seen = new Set(primary.map(keyOf));
+  for (const m of secondary) if (!seen.has(keyOf(m))) out.push({ ...m, origin: "context" });
+  return out;
+};
+const buildPackBlock = (matches) => (matches.length ? "PACKBLOCK" : "");
+const buildEntityBlock = (matches) => (matches.length ? "ENTITYBLOCK" : "");
+const helpers = { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEntityBlock };
+const walkerReturning = (text) => ({
+  warmWalker: { isEnabled: () => false },
+  resolveUtilityProvider: () => ({ provider: {}, providerId: "fake", model: "fake-model" }),
+  spawnUtilityAgent: async () => ({ text, provider: "fake", model: "fake-model" }),
+});
+const QUERY = "tell me about the widget deployment process in detail";
+const KEEP_BOTH = '[{"id":"pack:alpha","why":"relevant","score":80},{"id":"pack:beta","why":"related","score":70}]';
+const reinforcedBetween = (a, b) => graph.allEdges().some((e) =>
+  ((e.src === a && e.dst === b) || (e.src === b && e.dst === a)) && e.type === "related" && e.last_reinforced);
+
+(async () => {
+  // The integration path writes/reads the sqlite-backed graph. CI runs node:20
+  // (no node:sqlite), where graph.reinforce()/allEdges() are no-ops — so, like
+  // test-recall-graph.js, skip the graph-dependent assertions when the graph is
+  // unavailable. The pure cokeptPairs() unit tests above already ran and cover
+  // the selection logic on every node version.
+  if (!graph.available()) { console.log("cokept warming OK (integration skipped — no node:sqlite)"); return; }
+  // OFF (default): both packs kept, but NO reinforced edge is written
+  const off = await disc.run({ userText: QUERY, contextText: "", fullContext: QUERY, packLimit: 6, budget: {}, helpers, walkerOptions: walkerReturning(KEEP_BOTH) });
+  assert.ok(off.packMatches.some((m) => m.dir === "alpha") && off.packMatches.some((m) => m.dir === "beta"), "both packs kept");
+  assert.strictEqual(reinforcedBetween("pack:alpha", "pack:beta"), false, "warming OFF (default) writes no reinforced edge");
+
+  // ON: the co-kept, high-confidence, grounded pair warms its related edge
+  process.env.RECALL_COKEPT_WARMING = "on";
+  await disc.run({ userText: QUERY, contextText: "", fullContext: QUERY, packLimit: 6, budget: {}, helpers, walkerOptions: walkerReturning(KEEP_BOTH) });
+  assert.strictEqual(reinforcedBetween("pack:alpha", "pack:beta"), true, "warming ON reinforces the co-kept pair's related edge");
+  delete process.env.RECALL_COKEPT_WARMING;
+
+  console.log("cokept warming OK");
+})().catch((e) => { console.error(e); process.exit(1); });

package/test-extractive-injection.js

@@ -0,0 +1,70 @@
+// WS3: extractive on-open injection. The old headline surfaced Stance only, so
+// a fact living in State/Procedure/Journal never loaded even when it was the
+// reason the pack matched (Defect A — the felt regression). Extractive mode
+// renders Stance verbatim PLUS the exact lines that matched this message, from
+// anywhere in the pack, tagged by section and never paraphrased. Covers: cross-
+// section surfacing, verbatim text, section tags, Stance dedupe, per-section
+// cap, Stance-only fallback, and the unchanged classic headline path.
+const assert = require("assert");
+const { formatPackForContext } = require("./core/system-prompt");
+
+const pack = {
+  dir: "deploy-notes",
+  name: "Deploy Notes",
+  description: "how we ship",
+  parent: null,
+  tags: [],
+  sections: {
+    Stance: "Prefer GitOps for what runs in the cluster.\nNever force-push to main.",
+    Procedure: "Run the smoke test before every deploy.\nTag the release then push via git-release.",
+    State: "The ArgoCD sync for payments is currently paused.\nWaiting on Emmanuel's review.",
+    Journal: "2026-07-01 shipped v3.\n2026-07-02 rolled back v3 then re-shipped.\n2026-06-30 unrelated note about pizza.",
+  },
+};
+const packsLib = { readPack: () => null, listPacks: () => [] };
+
+// ── extractive: Stance verbatim + the matched State line, tagged, not paraphrased ──
+const matched = [
+  { section: "State", lineno: 1, text: "The ArgoCD sync for payments is currently paused.", score: 30 },
+  { section: "Procedure", lineno: 2, text: "Tag the release then push via git-release.", score: 20 },
+];
+const out = formatPackForContext(pack, packsLib, { extractive: true, matchedLines: matched });
+
+assert.ok(/#### Stance\nPrefer GitOps for what runs in the cluster\./.test(out), "Stance shown verbatim");
+assert.ok(/Never force-push to main\./.test(out), "full Stance body preserved");
+assert.ok(/#### State \(matched\)/.test(out), "matched State section is tagged");
+assert.ok(out.includes("The ArgoCD sync for payments is currently paused."), "the matched State fact is surfaced verbatim (Defect-A fix)");
+assert.ok(/#### Procedure \(matched\)/.test(out), "matched Procedure section is tagged");
+assert.ok(out.includes("Tag the release then push via git-release."), "matched Procedure line surfaced verbatim");
+// Un-matched noise must NOT be dumped: the pizza journal line never matched.
+assert.ok(!out.includes("pizza"), "unmatched Journal noise is not injected");
+assert.ok(!out.includes("Waiting on Emmanuel"), "unmatched State line is not injected");
+assert.ok(/open-claudia pack show deploy-notes/.test(out), "points to the full pack for more");
+
+// ── Stance dedupe: a matched line that IS a Stance line is not repeated ──
+const dupMatched = [{ section: "Stance", text: "Never force-push to main.", score: 20 },
+  { section: "State", text: "Prefer GitOps for what runs in the cluster.", score: 20 }]; // same text as a Stance line
+const outDup = formatPackForContext(pack, packsLib, { extractive: true, matchedLines: dupMatched });
+// "Prefer GitOps..." appears once (in Stance), not again under State (matched).
+const gitopsCount = (outDup.match(/Prefer GitOps for what runs in the cluster\./g) || []).length;
+assert.strictEqual(gitopsCount, 1, "a matched line equal to a Stance line is not duplicated");
+
+// ── per-section cap: at most EXTRACTIVE_LINES_PER_SECTION (4) lines per section ──
+const many = Array.from({ length: 9 }, (_, i) => ({ section: "Journal", text: `2026-07-${10 + i} note number ${i}`, score: 10 }));
+const outMany = formatPackForContext(pack, packsLib, { extractive: true, matchedLines: many });
+const journalBullets = (outMany.match(/note number \d/g) || []).length;
+assert.ok(journalBullets <= 4, `per-section cap holds (got ${journalBullets})`);
+
+// ── Stance-only fallback: extractive with no matched lines → Stance + pointer, no (matched) blocks ──
+const outNone = formatPackForContext(pack, packsLib, { extractive: true, matchedLines: [] });
+assert.ok(/#### Stance/.test(outNone), "Stance still shown when nothing matched");
+assert.ok(!/\(matched\)/.test(outNone), "no (matched) sections when there were no line hits");
+assert.ok(/Showing Stance\./.test(outNone), "fallback pointer explains only Stance is shown");
+
+// ── classic headline path unchanged: Stance only, heavier sections hidden ──
+const outHeadline = formatPackForContext(pack, packsLib, { headline: true });
+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");
+
+console.log("extractive injection OK");

package/test-pack-search.js

@@ -0,0 +1,79 @@
+// WS1: extractive per-line search (packs.searchLines). Unlike matchPacks,
+// which routes whole packs, searchLines returns the individual lines that
+// best match a query, tagged by section — the substrate the extractive
+// injector uses to surface a verbatim fact from anywhere in a pack, not just
+// Stance. Covers: cross-section retrieval, section tagging, verbatim text,
+// distinct-term scoring, dir scoping, k cap, stopword/empty guards, archived
+// exclusion.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "pack-search-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+
+const packs = require("./core/packs");
+
+packs.createPack({
+  dir: "deploy-notes",
+  name: "Deploy Notes",
+  description: "how we ship",
+  stance: "Prefer GitOps for what runs in the cluster.",
+  procedure: "Run the smoke test before every deploy.\nTag the release then push via git-release.",
+  state: "The ArgoCD sync for payments is currently paused.",
+  journal: "2026-07-01 deployed v3 to the cluster without incident.",
+});
+packs.createPack({
+  dir: "billing",
+  name: "Billing",
+  description: "invoices and refunds",
+  stance: "Refunds always require a manager approval.",
+  procedure: "Generate the invoice, then email it to the customer.",
+});
+
+// ── cross-section: a fact in Procedure/State/Journal is retrievable, proving
+//    searchLines reaches beyond Stance (the felt-regression fix). ──
+const argo = packs.searchLines("argocd sync payments");
+assert.ok(argo.length > 0, "finds a matching line");
+assert.strictEqual(argo[0].dir, "deploy-notes", "matched the right pack");
+assert.strictEqual(argo[0].section, "State", "line is tagged with its section (State, not Stance)");
+assert.ok(/ArgoCD sync for payments/.test(argo[0].text), "returns the verbatim source line");
+assert.ok(argo[0].lineno >= 1, "reports a 1-based line number");
+assert.ok(argo[0].score > 0, "reports a positive score");
+
+// ── verbatim: returned text is the source line trimmed, never paraphrased ──
+const smoke = packs.searchLines("smoke test deploy", { dir: "deploy-notes" });
+assert.ok(smoke.some((h) => h.text === "Run the smoke test before every deploy." && h.section === "Procedure"),
+  "verbatim line preserved exactly, correct section");
+
+// ── scoring: a line covering more distinct query terms outranks one covering
+//    fewer, so the injector's top hit is the densest match. ──
+const rank = packs.searchLines("release git-release push tag");
+assert.strictEqual(rank[0].section, "Procedure", "the line with the most distinct query terms ranks first");
+assert.ok(/git-release/.test(rank[0].text), "top hit is the multi-term line");
+
+// ── dir scoping: --pack restricts the search to one pack ──
+const scoped = packs.searchLines("approval invoice refund", { dir: "billing" });
+assert.ok(scoped.length > 0, "dir-scoped search returns billing lines");
+assert.ok(scoped.every((h) => h.dir === "billing"), "dir scoping excludes other packs");
+
+// ── k cap: never returns more than k hits ──
+const capped = packs.searchLines("the", { k: 2 }); // 'the' is a stopword → no terms
+assert.strictEqual(capped.length, 0, "a stopword-only query yields no terms and no hits");
+const capped2 = packs.searchLines("deploy invoice refund approval release", { k: 2 });
+assert.ok(capped2.length <= 2, "k caps the number of hits");
+
+// ── guards: empty query → [] ──
+assert.deepStrictEqual(packs.searchLines(""), [], "empty query returns nothing");
+assert.deepStrictEqual(packs.searchLines("   "), [], "whitespace query returns nothing");
+
+// ── no match → [] ──
+assert.deepStrictEqual(packs.searchLines("kubernetes helm quantum"), [], "no matching lines returns []");
+
+// ── archived packs are excluded from a corpus-wide search ──
+packs.archivePack("billing");
+const afterArchive = packs.searchLines("approval invoice refund");
+assert.ok(afterArchive.every((h) => h.dir !== "billing"), "archived pack lines are not surfaced");
+
+console.log("pack search OK");

package/test-provider-language.js

@@ -46,7 +46,26 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // provider-agnostic loose-credential capture (a pasted secret is stored
 // out-of-band and the turn stopped before the model — Codex refuses secrets in
 // its prompt, so the harness intercepts the paste itself).
-assert.strictEqual(pkg.version, "3.0.37", "release version must remain unchanged without explicit approval");
+// 3.0.40 approved by Sumeet 2026-07-18 ("please go ahead and work through end
+// to end till it's fully built and deploy out a new version for me ... I want
+// you to fully complete the plan then let me know to upgrade and test"): the
+// Pass-4 recall overhaul. Third cut — v3.0.38 bumped the version but forgot to
+// move THIS pin (pretest caught it); v3.0.39 fixed the pin but a new test
+// (test-cokept-warming.js) asserted a sqlite-graph write that no-ops on CI's
+// node:20 (no node:sqlite), so it now skips that path like test-recall-graph.js.
+// Payload unchanged: extractive on-open injection (Stance verbatim + fuzzy-
+// matched, section-tagged lines) surfaces the actual matched facts instead of a
+// headline; a walker score-gate drops weakly-relevant nodes below the relevance
+// floor and tightens the cascade so sticky auto-keeps route back to the judge; a
+// KPI ruler stamps per-version relevance/gate/warm columns. Co-kept Hebbian
+// warming ships dark (default OFF).
+// 3.0.41 approved by Sumeet 2026-07-18 ("Yes I think that's fine please fix it
+// and push it out"): verbose-off narration cleanup. The interim stream preview
+// showed the pre-tool "Let me…" narration and then settled to keep it as a
+// permanent message regardless of /verbose — only extended-thinking was gated.
+// finalizeStreamPreview now deletes the settled preview when /verbose is off, so
+// chat carries only the final answer; verbose ON still keeps the narration trail.
+assert.strictEqual(pkg.version, "3.0.41", "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-recall-evolution.js

@@ -168,7 +168,7 @@ assert.ok(fs.existsSync(path.join(backupRoot, "packs", "backfill-me")), "deduped
 metrics._resetForTest();
 const L = (o) => JSON.stringify(o) + "\n";
 fs.writeFileSync(metrics.LOG_FILE, [
-  L({ ts: "2026-06-01T00:00:00Z", v: "2.6.50", model: "haiku", tier: "full", seeds: [{ id: "pack:a" }], kept: [{ id: "pack:a" }, { id: "pack:b" }], latencyMs: 10000, costUsd: 0.01 }),
+  L({ ts: "2026-06-01T00:00:00Z", v: "2.6.50", model: "haiku", tier: "full", seeds: [{ id: "pack:a" }], kept: [{ id: "pack:a", score: 80 }, { id: "pack:b", score: 60 }], gate: { min: 55, out: ["pack:z"] }, warmed: [["pack:a", "pack:b"]], latencyMs: 10000, costUsd: 0.01 }),
   L({ ts: "2026-06-01T00:01:00Z", v: "2.6.50", use: ["pack:a"] }),
   L({ ts: "2026-06-02T00:00:00Z", v: "2.6.50", model: "haiku", tier: "full", gated: true, latencyMs: 5 }),
   L({ ts: "2026-07-01T00:00:00Z", v: "2.6.59", model: "haiku", tier: "seeds", seeds: [{ id: "pack:a" }], kept: [{ id: "pack:a" }], latencyMs: 2000, costUsd: 0, auto: { kept: ["pack:a"], dropped: ["pack:z"] } }),
@@ -183,10 +183,17 @@ assert.strictEqual(v50.gatedPct, 50);
 assert.strictEqual(v50.rescuePct, 100, "kept-without-seed counts as a rescue turn");
 assert.strictEqual(v50.noisePct, 50, "one of two kept nodes was used");
 assert.deepStrictEqual(v50.models, ["haiku"]);
+// Pass-4 (WS0) ruler columns: relevance (avg walker score), gate-pass, warmings
+assert.strictEqual(v50.avgKeptScore, 70, "relevance = mean walker score across kept nodes (80,60)");
+assert.strictEqual(v50.gatedNodes, 1, "score-gate dropped one node this window");
+assert.strictEqual(v50.gateFiredPct, 100, "the one gate-active turn fired");
+assert.strictEqual(v50.warmings, 1, "one co-kept warming applied");
 const v59 = rows.find((r) => r.v === "2.6.59");
 assert.strictEqual(v59.rescuePct, 0);
 assert.strictEqual(v59.autoKept, 1);
 assert.strictEqual(v59.autoDropped, 1);
+assert.strictEqual(v59.avgKeptScore, null, "a window with no scored keeps reports null relevance, not 0");
+assert.strictEqual(v59.warmings, 0, "no warmings logged → zero");
 assert.strictEqual(rows.find((r) => r.v === kpi.LEGACY_VERSION).walkerFailPct, 100);
 
 metrics.appendKpi({ trigger: "test", health: { rescueRate: 0.25, noiseRate: 0.5, avgLatencyMs: 8000 }, window: { turns: 40 } });
@@ -197,6 +204,7 @@ assert.ok(snaps[0].v && snaps[0].ts, "snapshots are version-stamped");
 
 const table = kpi.renderTable(rows);
 assert.ok(/2\.6\.50/.test(table) && /rescue/.test(table), "table renders versions and metrics");
+assert.ok(/relevance/.test(table) && /warm/.test(table), "table surfaces the Pass-4 ruler columns");
 const html = kpi.htmlReport();
 assert.ok(/<svg/.test(html) && /2\.6\.59/.test(html) && /rescue/i.test(html), "HTML report has charts and versions");
 const outPath = kpi.writeHtmlReport(path.join(tmp, "kpi.html"));

package/test-score-gate.js

@@ -0,0 +1,104 @@
+// WS4: injection score-gate (the keystone). A walker-kept node scoring below
+// the relevance floor (minRelevanceScore, default 55) is NOT injected — this is
+// what stops a weakly-linked/incidental pack from riding along (Defect B, the
+// cascade precision leak). The gate only fires on a full-tier successful walk;
+// a fail-open walk (garbage/empty output → scores null) bypasses it and takes
+// the classic top-3 user-seed path. Crucially, a successful walk that gates
+// EVERY node leaves an empty (non-null) kept map → inject nothing — which is a
+// different signal from fail-open (keep the strongest seeds). This test drives
+// the gate end-to-end through disc.run() with an injected fake walker.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-gate-"));
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+process.env.RECALL_DISCOVERER_WALKER = "on"; // walker ON — we inject a fake one
+process.env.RECALL_METRICS = "off";
+process.env.TOOLS_DIR = path.join(tmp, "tools");
+process.env.RECALL_CASCADE = "off"; // send both candidates straight to the judge (no history/shadow randomness)
+delete process.env.RECALL_MIN_RELEVANCE_SCORE; // ensure the default floor (55) applies, not an operator pin
+
+const disc = require("./core/recall/discoverer");
+
+// Two packs; matchPacks returns BOTH for a "widget" query, so both become
+// full-tier candidates that reach the walker as pack:alpha / pack:beta.
+const packs = {
+  alpha: { dir: "alpha", name: "Alpha", description: "alpha pack",
+    parent: null, tags: [], sections: { Stance: "alpha stance", Procedure: "", State: "", Journal: "" } },
+  beta: { dir: "beta", name: "Beta", description: "beta pack",
+    parent: null, tags: [], sections: { Stance: "beta stance", Procedure: "", State: "", Journal: "" } },
+};
+const packsLib = {
+  matchPacks: (text) => /widget/.test(text)
+    ? [{ dir: "alpha", name: "Alpha", score: 5 }, { dir: "beta", name: "Beta", score: 4 }]
+    : [],
+  readPack: (dir) => packs[dir] || null,
+  listPacks: () => Object.values(packs),
+  searchLines: () => [], // extractive path present but yields no line hits here — keeps the block simple
+  PACKS_DIR: tmp,
+};
+const entitiesLib = { matchEntities: () => [], readEntity: () => null, listEntities: () => [], ENTITIES_DIR: tmp };
+const mergeMatches = (primary, secondary, keyOf) => {
+  const out = primary.map((m) => ({ ...m, origin: "user" }));
+  const seen = new Set(primary.map(keyOf));
+  for (const m of secondary) if (!seen.has(keyOf(m))) out.push({ ...m, origin: "context" });
+  return out;
+};
+let builtPacks = null;
+const buildPackBlock = (matches) => { builtPacks = matches; return matches.length ? "PACKBLOCK" : ""; };
+const buildEntityBlock = (matches) => (matches.length ? "ENTITYBLOCK" : "");
+const helpers = { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEntityBlock };
+
+// Inject a fake walker: force the cold path (warm disabled), a fixed provider,
+// and a canned agent reply. walk() parses the JSON array out of `text`.
+function walkerReturning(text) {
+  return {
+    warmWalker: { isEnabled: () => false },
+    resolveUtilityProvider: () => ({ provider: {}, providerId: "fake", model: "fake-model" }),
+    spawnUtilityAgent: async () => ({ text, provider: "fake", model: "fake-model" }),
+  };
+}
+const QUERY = "tell me about the widget deployment process in detail";
+const runGate = (walkerText, extra = {}) => disc.run({
+  userText: QUERY, contextText: "", fullContext: QUERY,
+  packLimit: 6, budget: {}, helpers, walkerOptions: walkerReturning(walkerText), ...extra,
+});
+
+(async () => {
+  // ── Test 1: default floor 55 — alpha@80 kept, beta@40 gated out ──────────────
+  builtPacks = null;
+  const res1 = await runGate('[{"id":"pack:alpha","why":"directly relevant","score":80},{"id":"pack:beta","why":"weakly linked","score":40}]');
+  assert.strictEqual(res1.tier, "full", "substantive widget query lands on the full tier");
+  assert.ok(res1.packMatches.some((m) => m.dir === "alpha"), "alpha (score 80 ≥ 55) is kept");
+  assert.ok(!res1.packMatches.some((m) => m.dir === "beta"), "beta (score 40 < 55) is gated out of injection");
+  assert.ok(res1.why["pack:alpha"], "kept alpha carries its why");
+  assert.ok(!res1.why["pack:beta"], "gated beta is absent from the why map");
+  assert.ok(builtPacks && builtPacks.length === 1 && builtPacks[0].dir === "alpha", "only alpha reaches the block builder");
+
+  // ── Test 2: gate disabled (floor 0) — beta@40 now survives ───────────────────
+  process.env.RECALL_MIN_RELEVANCE_SCORE = "0";
+  const res2 = await runGate('[{"id":"pack:alpha","why":"relevant","score":80},{"id":"pack:beta","why":"weak","score":40}]');
+  assert.ok(res2.packMatches.some((m) => m.dir === "alpha") && res2.packMatches.some((m) => m.dir === "beta"),
+    "floor 0 → gate off → both kept, including beta@40");
+  delete process.env.RECALL_MIN_RELEVANCE_SCORE;
+
+  // ── Test 3: fail-open — garbage walker output (scores null) bypasses the gate ─
+  const res3 = await runGate("this is not json at all, sorry");
+  assert.ok(res3.packMatches.some((m) => m.dir === "alpha") && res3.packMatches.some((m) => m.dir === "beta"),
+    "unparseable walk → fail-open keeps the strongest user seeds, gate is bypassed");
+
+  // ── Test 4: all-low scores at floor 55 — inject NOTHING (empty, not fail-open) ─
+  // The distinguishing case: a successful walk that gates every node must leave
+  // an empty kept set (packMatches [], packBlock ""), NOT fall back to the
+  // fail-open top-3 seed path (which would wrongly keep both).
+  builtPacks = null;
+  const res4 = await runGate('[{"id":"pack:alpha","why":"meh","score":30},{"id":"pack:beta","why":"meh","score":20}]');
+  assert.strictEqual(res4.packMatches.length, 0, "all scores below floor → nothing injected (empty non-null kept map)");
+  assert.strictEqual(res4.packBlock, "", "empty kept set renders no packBlock");
+  assert.deepStrictEqual(res4.why, {}, "empty kept set → empty why map (distinct from fail-open)");
+  assert.strictEqual(builtPacks && builtPacks.length, 0, "the block builder is handed zero packs, proving this is NOT the fail-open path");
+
+  console.log("score gate OK");
+})().catch((e) => { console.error(e); process.exit(1); });

package/test-walker-score.js

@@ -0,0 +1,69 @@
+// WS2: the walker's score contract. The router now emits {id, why, score};
+// walk() parses score into a parallel id→0-100 map while kept stays id→why, so
+// downstream (injection score-gate, asymmetric warming) gets a relevance signal
+// without reshaping every why-consumer. A missing/garbage score defaults to a
+// neutral 60 so a parse hiccup never silently buries a node the router kept.
+const assert = require("assert");
+
+process.env.RECALL_DISCOVERER_WALKER = "on"; // ensure WALKER_ENABLED at module load
+const disc = require("./core/recall/discoverer");
+
+const candidates = [
+  { id: "pack:alpha", name: "Alpha" },
+  { id: "pack:beta", name: "Beta" },
+  { id: "pack:gamma", name: "Gamma" },
+  { id: "pack:delta", name: "Delta" },
+  { id: "pack:epsilon", name: "Epsilon" },
+];
+
+// Drive the real runWalker → parse path with an injected cold-spawn agent.
+function fakeWalk(replyArray, text) {
+  return disc.walk("do the alpha thing", "", candidates, {
+    warmWalker: { isEnabled: () => false }, // force the cold spawn path
+    resolveUtilityProvider: () => ({ provider: {}, providerId: "fake", model: "fake-model" }),
+    spawnUtilityAgent: async () => ({
+      text: text != null ? text : JSON.stringify(replyArray),
+      provider: "fake",
+      model: "fake-model",
+    }),
+  });
+}
+
+(async () => {
+  const res = await fakeWalk([
+    { id: "pack:alpha", why: "directly about alpha", score: 92 },
+    { id: "pack:beta", why: "missing score defaults neutral" }, // → 60
+    { id: "pack:gamma", why: "over the top", score: 150 },       // → 100
+    { id: "pack:delta", why: "negative", score: -20 },          // → 0
+    { id: "pack:epsilon", why: "fractional", score: 33.7 },     // → 34
+  ]);
+
+  assert.ok(res.kept instanceof Map, "kept is a Map");
+  assert.ok(res.scores instanceof Map, "scores is a parallel Map");
+  assert.strictEqual(res.kept.get("pack:alpha"), "directly about alpha", "why preserved verbatim (kept stays id→why string)");
+  assert.strictEqual(res.scores.get("pack:alpha"), 92, "explicit score parsed");
+  assert.strictEqual(res.scores.get("pack:beta"), 60, "missing score → neutral 60 (fail-open, never buried)");
+  assert.strictEqual(res.scores.get("pack:gamma"), 100, "score clamped to 100");
+  assert.strictEqual(res.scores.get("pack:delta"), 0, "score clamped to 0");
+  assert.strictEqual(res.scores.get("pack:epsilon"), 34, "fractional score rounded");
+
+  // Hallucinated ids (not among candidates) are dropped from BOTH maps.
+  const res2 = await fakeWalk([
+    { id: "pack:alpha", why: "ok", score: 70 },
+    { id: "pack:HALLUCINATED", why: "invented", score: 99 },
+  ]);
+  assert.ok(res2.kept.has("pack:alpha"), "known id kept");
+  assert.ok(!res2.kept.has("pack:HALLUCINATED"), "unknown id dropped from kept");
+  assert.ok(!res2.scores.has("pack:HALLUCINATED"), "unknown id dropped from scores");
+
+  // Non-numeric score → neutral 60, never NaN.
+  const res3 = await fakeWalk([{ id: "pack:alpha", why: "x", score: "high" }]);
+  assert.strictEqual(res3.scores.get("pack:alpha"), 60, "non-numeric score → neutral 60");
+
+  // Unparseable output → fail-open: both maps null, no throw.
+  const res4 = await fakeWalk(null, "sorry, I cannot help with that");
+  assert.strictEqual(res4.kept, null, "no JSON array → kept null (fail-open)");
+  assert.strictEqual(res4.scores, null, "no JSON array → scores null (fail-open)");
+
+  console.log("walker score OK");
+})().catch((e) => { console.error(e); process.exit(1); });