ruvnet-brain 2.5.2 → 2.9.0

package/README.md

@@ -4,7 +4,7 @@
 
 # 🧠 RuvNet Brain
 
-### 🧠 RuvNet Brain — [![RuvNet Brain version 2.5.2 — updated 2026-07-12 21:11 EDT](https://img.shields.io/badge/version_2.5.2-updated_2026--07--12_21:11_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
+### 🧠 RuvNet Brain — [![RuvNet Brain version 2.9.0 — updated 2026-07-14 05:59 EDT](https://img.shields.io/badge/version_2.9.0-updated_2026--07--14_05:59_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
 
 **A portable, source-grounded brain over Reuven Cohen's (rUv's) RuvNet stack — delivered as a Claude Code plugin that makes Claude _use_ the stack instead of fighting it.**
 
@@ -77,7 +77,7 @@ So 2.5.1 makes it a **wall, not advice**: a `PreToolUse` gate that **blocks any
 
 | | v1 (0.x–1.x) | v2.0 |
 |---|---|---|
-| **Corpus** | 24 repos built | **32 repos** built (of 197 live ruvnet repos), each verified by a live retrieval query |
+| **Corpus** | 24 repos built | **36 repos** built (of 197 live ruvnet repos), each verified by a live retrieval query |
 | **Depth** (flagship `ruvector`) | 18,491 passages · **0** full source bodies | **28,018 passages · 2,996 full bodies** — depth also restored to `agent-harness-generator` (8,896/715), `ruview` (7,434/765), `open-claude-code` (195/69) |
 | **Corpus QA gate** | none | every store must prove *embeds correctly + reads correctly* — vector count == passage count, depth floors, a 3-passage self-retrieval round-trip per store — **72/72 store-variants PASS**, wired fail-closed into the nightly publish |
 | **Retrieval eval** | 12 frozen questions | **120 frozen, hash-pinned questions** across 5 strata; promotion gated on Wilson lower bounds, fail-closed — it blocked a real release this morning, which is the feature working |
@@ -212,7 +212,7 @@ Plus: the **“take the wheel” behavioral pipeline** (below), a **4-level beha
 
 ## How it works
 
-The expensive work happens **once, at build time**: every covered repo is deep-walked (whole files, full function bodies, plus a symbol index), embedded into **two** vector variants (MiniLM-384 for edge/portability, bge-768 for depth) stored on-disk in **RVF / HNSW**, and distilled into a concepts + capability layer of per-repo primers and cards. That's **129,037 source chunks**. At **query time**, `search_ruvnet` searches every repo's store at once, pools the hits, and runs them through **one cross-encoder rerank** on a common scale — so the truly relevant file wins regardless of which repo it lives in — then returns whole source files, each labeled by repo and path.
+The expensive work happens **once, at build time**: every covered repo is deep-walked (whole files, full function bodies, plus a symbol index), embedded into **two** vector variants (MiniLM-384 for edge/portability, bge-768 for depth) stored on-disk in **RVF / HNSW**, and distilled into a concepts + capability layer of per-repo primers and cards. That's **129,685 source chunks**. At **query time**, `search_ruvnet` searches every repo's store at once, pools the hits, and runs them through **one cross-encoder rerank** on a common scale — so the truly relevant file wins regardless of which repo it lives in — then returns whole source files, each labeled by repo and path.
 
 ![RuvNet Brain architecture pipeline](assets/diagrams/architecture-pipeline.svg)
 
@@ -246,7 +246,7 @@ The brain answers **both** kinds of questions. **Name the repo or ask something
 
 ## What it covers
 
-32 of rUv's repos in the [ruvnet](https://github.com/ruvnet) org — the reusable **building blocks** you'd actually compose into a system — each deep-walked and embedded in both variants. The core blocks below also carry symbol indexes and capability cards (the 8 newest repos are findable by name; their capability cards are coming).
+36 of rUv's repos in the [ruvnet](https://github.com/ruvnet) org — the reusable **building blocks** you'd actually compose into a system — each deep-walked and embedded in both variants. The core blocks below also carry symbol indexes and capability cards (the 8 newest repos are findable by name; their capability cards are coming).
 
 ![The RuvNet stack the brain covers](primer/assets/diagrams/ruvnet-stack.svg)
 
@@ -322,7 +322,7 @@ node forge-ask-all.mjs --dir . --q "How does RuVector implement HNSW vector sear
 
 This project versions in the open (see the live badge up top for the exact plugin version; the downloadable knowledge bundle is a separate track) — we don't claim “done,” “complete,” or “zero hallucinations.” Where it stands:
 
-- ✅ **The grounding brain is real and proven** — 32 repos, 129,037 chunks, dual embeddings, cross-encoder rerank, plugin (MCP tool + enforcement hook + skill), all re-runnable.
+- ✅ **The grounding brain is real and proven** — 36 repos, 129,685 chunks, dual embeddings, cross-encoder rerank, plugin (MCP tool + enforcement hook + skill), all re-runnable.
 - ✅ **Code-level depth** — the code-rich repos are indexed to full function bodies; “how is it implemented?” returns the implementation. Verified in the shipped bundle (clean-room 3/3).
 - ✅ **Routing holds** — named 47/48, described 26/28, scenario 7/8; behavioral L1–L4 all pass; private stores fenced out of the public bundle (zero-leak verified).
 - ⚠️ **Two routing residuals** (above) — surfaced, not hidden.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
-  "version": "2.5.2",
-  "description": "One-command installer for RuvNet Brain \u2014 a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
+  "version": "2.9.0",
+  "description": "One-command installer for RuvNet Brain — a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
   "type": "module",
   "bin": {
     "ruvnet-brain": "bin/install.mjs"

package/scripts/falsify.mjs

@@ -147,6 +147,49 @@ export const CHECKS = [
       };
     },
   },
+  {
+    id: 'does-memory-actually-recall',
+    asked: '"Is AgentDB actually storing AND recalling, or is it just small bits?"',
+    why: 'I reported AgentDB as broken THREE times. It was never broken. I called `memory search` positionally when the CLI wants -q, then broke my own canary test with a bad grep, and reported MY test defects as PRODUCT defects. This check does the round trip so I can never again mistake my own sloppiness for a broken tool.',
+    run: () => {
+      // MEMORY_DB override exists so this check can be TESTED AGAINST A BROKEN STATE. A check nobody
+      // has watched fail is not a check. (My first two attempts to test it were themselves broken —
+      // which is the entire reason this check exists.)
+      const db = process.env.MEMORY_DB || path.join(ROOT, '.swarm', 'memory.db');
+      if (!fs.existsSync(db)) return { ok: false, detail: 'no memory.db — memory is not initialised' };
+
+      // 1. Is it COLLECTING? (rows, embedded, current)
+      const q = (sql) => (spawnSync('sqlite3', [db, sql], { encoding: 'utf8' }).stdout || '').trim();
+      const total = Number(q('SELECT COUNT(*) FROM memory_entries;'));
+      const embedded = Number(q("SELECT SUM(embedding IS NOT NULL AND LENGTH(embedding)>50) FROM memory_entries;"));
+      const ageH = (Date.now() - Number(q('SELECT MAX(created_at) FROM memory_entries;'))) / 3600_000;
+
+      // 2. Does it SURVIVE compaction / session end? (the whole point)
+      const pre = Number(q("SELECT COUNT(*) FROM memory_entries WHERE key LIKE 'session-precompact%';"));
+      const end = Number(q("SELECT COUNT(*) FROM memory_entries WHERE key LIKE 'session-sessionend%';"));
+
+      // 3. Does it RECALL? A real semantic round-trip through the REAL CLI — not a DB peek.
+      const r = spawnSync('npx', ['ruflo@latest', 'memory', 'search', '-q', 'nightly job supervision heartbeat receipts'], {
+        cwd: ROOT, encoding: 'utf8', timeout: 120_000,
+      });
+      const recalled = /Found\s+\d+\s+results/.test(r.stdout || '') && !/Found\s+0\s+results/.test(r.stdout || '');
+
+      const problems = [];
+      if (total < 10) problems.push(`only ${total} entries stored`);
+      if (embedded / Math.max(total, 1) < 0.9) problems.push(`only ${embedded}/${total} entries are embedded — semantic recall will be partial`);
+      if (ageH > 48) problems.push(`newest entry is ${ageH.toFixed(0)}h old — capture may have stopped`);
+      if (pre === 0) problems.push('ZERO PreCompact snapshots — context will NOT survive a compaction');
+      if (end === 0) problems.push('ZERO SessionEnd snapshots — context will NOT survive a session restart');
+      if (!recalled) problems.push('semantic search returned NOTHING — recall is dead');
+
+      return {
+        ok: problems.length === 0,
+        detail: problems.length
+          ? problems.join('; ')
+          : `${total} entries (${embedded} embedded), ${pre} PreCompact + ${end} SessionEnd snapshots, semantic recall returns results`,
+      };
+    },
+  },
   {
     id: 'is-ci-actually-green',
     asked: '"Why am I getting failure notifications from GitHub?"',

package/scripts/metaharness-receipts.mjs

@@ -43,22 +43,29 @@ export function loadReceipts(file) {
 }
 
 const fmt$ = (n) => `$${n < 0.01 ? n.toFixed(5) : n.toFixed(4)}`;
+// Measured wall-clock, human-readable. '-' when the receipt has no duration — never invented.
+const fmtT = (ms) => {
+  if (typeof ms !== 'number' || !(ms > 0)) return '-';
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60_000)}m${String(Math.round((ms % 60_000) / 1000)).padStart(2, '0')}s`;
+};
 
 export function formatTable(rows) {
   if (!rows.length) return 'No routing receipts yet.\nRoute something cheap first:  node scripts/route-cheap.mjs --task "<text>"';
 
   // `channel` + `instead of` (2026-07-13): subagent receipts arrived with a per-row baseline — the
   // model that agent WOULD have inherited — so a single global "frontier" column would misreport them.
-  const header = ['date', 'channel', 'task class', 'model used', 'instead of', 'est. cost', 'est. baseline', 'saved'];
+  const header = ['date', 'channel', 'task class', 'model used', 'instead of', 'est. cost', 'est. baseline', 'saved', 'time'];
   const body = rows.map((r) => [
     (r.ts || '').replace('T', ' ').slice(0, 16),
-    r.source === 'claude-subagent' ? 'subagent' : 'openrouter',
+    r.source === 'claude-subagent' ? 'subagent' : r.source === 'calibration' ? 'calibrate' : 'openrouter',
     r.task_class || '?',
     r.model,
     r.frontier_ref || 'claude-opus-4.8',
     fmt$(r.est_cost ?? 0),
     fmt$(r.est_frontier_cost ?? 0),
     fmt$(r.saved),
+    fmtT(r.duration_ms), // measured, never estimated — '-' when absent
   ]);
   const widths = header.map((h, i) => Math.max(h.length, ...body.map((row) => row[i].length)));
   const line = (cells) => cells.map((cell, i) => cell.padEnd(widths[i])).join('  ');
@@ -67,19 +74,58 @@ export function formatTable(rows) {
   const totalFrontier = rows.reduce((s, r) => s + (r.est_frontier_cost || 0), 0);
   const totalSaved = rows.reduce((s, r) => s + r.saved, 0);
   const ratio = totalCost > 0 ? (totalFrontier / totalCost).toFixed(1) : '?';
+  // Lead with the PERCENTAGE — "$1.83" reads as pocket change; "68% cheaper" is the actual
+  // message (Stuart, 2026-07-13). Dollars stay for auditability; percent carries the story.
+  const pct = totalFrontier > 0 ? Math.round((totalSaved / totalFrontier) * 100) : 0;
 
   // Baselines now vary per row; name them all rather than picking one and implying it covers everything.
   const baselines = [...new Set(rows.map((r) => r.frontier_ref || 'claude-opus-4.8'))].join(', ');
+  const timedTotal = rows.reduce((s, r) => s + (typeof r.duration_ms === 'number' && r.duration_ms > 0 ? r.duration_ms : 0), 0);
+  const timedRows = rows.filter((r) => typeof r.duration_ms === 'number' && r.duration_ms > 0).length;
+  // TIME as a percentage, like cost — "20 seconds" is trivia; "~40% faster" is the message
+  // (Stuart, 2026-07-13: cheaper AND faster = fundamentally more efficient). Only rows carrying a
+  // MEASURED baseline_duration_ms (written by the calibration harness) enter this comparison.
+  const paired = rows.filter((r) => r.duration_ms > 0 && r.baseline_duration_ms > 0);
+  const pairedRouted = paired.reduce((s, r) => s + r.duration_ms, 0);
+  const pairedBase = paired.reduce((s, r) => s + r.baseline_duration_ms, 0);
+  const fasterPct = pairedBase > 0 ? Math.round((1 - pairedRouted / pairedBase) * 100) : null;
+  // Say what the measurement actually says — FASTER, SLOWER, or parity. The 2026-07-13
+  // calibration measured cheap tiers at speed PARITY on micro-tasks (startup dominates);
+  // a card that only knows how to say "faster" would have lied.
+  const speedBadge = fasterPct === null ? ''
+    : fasterPct >= 5 ? `  ·  ⚡ ~${fasterPct}% FASTER (measured, n=${paired.length})`
+    : fasterPct <= -5 ? `  ·  ⏱ ~${-fasterPct}% slower on routed tier (measured, n=${paired.length})`
+    : `  ·  ⚡ speed parity (measured, n=${paired.length})`;
   const subagents = rows.filter((r) => r.source === 'claude-subagent').length;
 
+  // The card leads with the PERCENTAGE and a spent-vs-unrouted bar — "$1.83" reads as pocket
+  // change; "68% cheaper", drawn, is the message (Stuart, 2026-07-13). The dollar table stays
+  // below for auditability; every number still traces to a receipt row.
+  const BAR = 30;
+  const withBar = totalFrontier > 0 ? Math.min(BAR, Math.max(1, Math.round(BAR * (totalCost / totalFrontier)))) : BAR;
+  const drawBar = (n) => '█'.repeat(n) + '░'.repeat(BAR - n);
+  const rule = '─'.repeat(70);
   return [
+    rule,
+    `  💰 SAVED ~${pct}%${speedBadge}  ·  ~${ratio}× cheaper  ·  ${rows.length} routed task(s) (${subagents} subagent, ${rows.length - subagents} openrouter/calibration)`,
+    '',
+    `  without routing    ${drawBar(BAR)}  ${fmt$(totalFrontier)}`,
+    `  with MetaHarness   ${drawBar(withBar)}  ${fmt$(totalCost)}   → ~${fmt$(totalSaved)} kept`,
+    rule,
     line(header),
     line(widths.map((w) => '-'.repeat(w))),
     ...body.map(line),
     '',
-    `${rows.length} routed task(s) (${subagents} subagent, ${rows.length - subagents} openrouter) · est. spent ${fmt$(totalCost)} vs ${fmt$(totalFrontier)} unrouted (${baselines}) · saved ~${fmt$(totalSaved)} (~${ratio}x cheaper)`,
+    `Baselines: ${baselines} — the model each task would have run on if it had not been routed.`,
     'Pricing is live-verified. Token counts are measured OR estimated per row (each row records which, in token_source).',
-    'Baseline = the model the task would have run on if it had not been routed.',
+    // Time honesty: durations are MEASURED wall-clock of the routed run. A "time saved vs baseline"
+    // number requires a measured per-tier speed baseline (the calibration batch) — until that exists
+    // we state the gap instead of inventing the comparison.
+    fasterPct !== null
+      ? `Time, measured: routed ${fmtT(pairedRouted)} vs baseline ${fmtT(pairedBase)} on ${paired.length} calibrated task(s) → ${fasterPct >= 5 ? `~${fasterPct}% faster` : fasterPct <= -5 ? `~${-fasterPct}% slower (startup-dominated micro-tasks — speed wins come from parallel fan-out and long generations, measured from real dispatches)` : 'speed parity'}. Uncalibrated rows show routed time only.`
+      : timedTotal > 0
+        ? `Measured time on routed models: ${fmtT(timedTotal)} across ${timedRows} timed task(s). Time-SAVED vs baseline: not yet measured — appears after the per-tier calibration run.`
+        : 'No measured durations in these receipts yet. Time-saved reporting activates after the per-tier calibration run.',
   ].join('\n');
 }
 

package/scripts/route-cheap.mjs

@@ -82,7 +82,9 @@ const fmt$ = (n) => `$${n < 0.01 ? n.toFixed(5) : n.toFixed(4)}`;
 
 export function receiptLine(model, costs) {
   const ref = costs.ref && costs.ref !== FRONTIER.name ? costs.ref : 'frontier';
-  return `\x1b[2m⚡ MetaHarness: routed to ${model} (est. ${fmt$(costs.cost)} vs ${fmt$(costs.frontier)} ${ref} — saved ~${fmt$(costs.saved)})\x1b[0m`;
+  // Percentage leads — "saved ~$0.005" reads as noise, "~97% cheaper" is the message (Stuart, 2026-07-13).
+  const pct = costs.frontier > 0 ? Math.round((costs.saved / costs.frontier) * 100) : 0;
+  return `\x1b[2m⚡ MetaHarness: routed to ${model} — ~${pct}% cheaper (est. ${fmt$(costs.cost)} vs ${fmt$(costs.frontier)} ${ref}, saved ~${fmt$(costs.saved)})\x1b[0m`;
 }
 
 // Load OPENROUTER_API_KEY from ruvnet-brain/.env if not already in env. Value never printed/logged.