ruvnet-brain 3.9.134-dev → 4.0.2

package/plugin/skills/rvbc/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: rvbc
+description: Open the RuvNet Brain Console in Claude Code and Codex when the user says "Configure RuvNet Brain", mentions "rvbc", asks for the Brain Console, or wants to configure or inspect RuvNet Brain. Claude Code supports /rvbc; Codex invokes the native $ruvnet-brain:rvbc skill.
+updated: 2026-07-30
+---
+
+# RuvNet Brain Console
+
+“Configure RuvNet Brain” opens this Console in Claude Code and Codex. Claude Code also supports
+`/rvbc`; Codex invokes this skill as `$ruvnet-brain:rvbc` because custom plugin slash commands are
+not part of the Codex CLI slash-command surface.
+
+1. Say one short sentence: "Opening it now; it scans live while you watch."
+2. Resolve the installed runtime at
+   `${RUVNET_BRAIN_KB:-$HOME/.cache/ruvnet-brain/kb}/.console-runtime/scripts/onboarding-console.mjs`.
+   A current-repository `scripts/onboarding-console.mjs` is allowed only for an explicit developer
+   checkout. Never fall back to a guessed `~/Code` path.
+3. Run `node <resolved-script> --serve --open` in the background.
+4. Give the URL immediately. Do not promise a duration; the page reports its own scan progress.
+
+An already-running server is success. The Console is read-only until the user chooses an action;
+every change must be explained and reversible. If the script cannot be located or the server fails,
+report the exact failure plainly instead of claiming the Console opened.

package/plugin/skills/savings/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: savings
+description: Show the MetaHarness routing ledger inline — which model each task was routed to, what it displaced, and the percentage + dollars saved — plus the learned router's training state. Use when the user says "savings", "show my savings", "metaharness report", "metaharness/report", "routing report", "routing receipts", "who is the router choosing", "how much has routing saved me", "is the meta harness working", or "show me the routing". All numbers come from the real receipts log; never fake or extrapolate a number.
+updated: 2026-07-13
+---
+
+# Savings — the MetaHarness routing ledger, inline
+
+Show the user their routing wins the way a bank statement shows transactions: real rows, real
+totals, zero vibes. Everything below comes from live artifacts on their machine; if a file is
+missing or empty, say exactly that — an honest "nothing routed yet" builds more trust than a
+padded number.
+
+## Steps (run these, verbatim — then render)
+
+1. **The ledger**:
+   `node scripts/metaharness-receipts.mjs`
+   (falls back to `~/.claude/metaharness/routing-receipts.jsonl` raw if the script is absent —
+   the plugin repo root or the installed package both carry it under `scripts/`).
+2. **The learner's state**:
+   `node -e "import(REPO+'/scripts/metaharness-router.mjs').then(m=>{const r=m.loadLabelledRows();console.log(JSON.stringify({labels:r.rows.length,needed:m.MIN_LABELS}))})"`
+3. Optional, if the user asks who decides: run one live decision
+   `node scripts/model-router-engine.mjs --prompt "<their current task>"` and quote `routedBy`.
+
+## Render
+
+The receipts script already draws the full card (percentage-first headline + spent-vs-unrouted
+bar + audit table) — **show its output verbatim in a code block**; do not re-format or re-total
+it. Then append the learner's state on two lines:
+
+```
+🧠 Learned router: <routedBy state>
+  <labels>/<needed> outcome examples → <"learning-routed decisions live" | "cold-start: static
+  tiers deciding (honest fallback) — N more outcomes to go">
+```
+
+## Hard rules
+
+- **Never fake a number.** Every dollar figure must trace to a receipt row. If `token_source`
+  says estimated, the totals line keeps the script's own "est." qualifier.
+- **Print the honest router state.** If the learner is below MIN_LABELS, say cold-start plainly —
+  the fallback tiers still save money and that is a true story worth telling.
+- **One screen.** Cap the table at 10 most-recent rows; state "+N earlier rows" if truncated.
+- After showing the ledger, offer ONE next action, not a menu: if labels < 20, offer the
+  calibration run ("want me to train it up with a $0 calibration batch?"); otherwise offer
+  nothing.

package/plugin/skills/whats-new/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: whats-new
+description: Explain what is new in the installed RuvNet Brain release from live version metadata and the curated release notes. Use for "/whats-new", "what's new", "what changed", "new release", or "show me the latest Brain improvements". Never claim a 4.0 version unless the installed version actually starts with 4.
+updated: 2026-07-28
+---
+
+# What is new
+
+Ground the answer in files that exist now; do not recite release claims from memory.
+
+1. Read the installed plugin version from `.codex-plugin/plugin.json` relative to this skill's
+   plugin root. If that is unavailable, read the current checkout's `plugin/.codex-plugin/plugin.json`.
+2. Locate `docs/RELEASE-NOTES-4.0.md` in the current repository, then
+   `~/Code/ruvnet-brain/docs/RELEASE-NOTES-4.0.md`. Read it before summarizing.
+3. State the installed version exactly. Do not say the user is on 4.0 unless it starts with `4.`.
+   For a 3.9 development version, describe verified items as "4.0-line enhancements landing in
+   3.9.x", using the release note's own status language.
+4. Summarize only the curated highlights and their evidence status. Never invent metrics or turn
+   newly collecting measurement into proof of improvement.
+5. End by offering to open the Console through the native `brain-console` workflow.
+
+If the release notes are missing, say they are unavailable and do not fabricate a highlight.

package/scripts/adr-backfill.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * adr-backfill.mjs — lift status and dates into frontmatter where tooling can read them.
+ *
+ * THE GAP, measured 2026-07-22: 12 of 32 ADRs carried NO frontmatter status and NO dates, and 9
+ * more had a creation date but no `updated`. The owner's requirement is exact: *"One thing I ALWAYS
+ * want you to do is indicate in an ADR what the status is... they should have a time and date
+ * stamped on when they were initially written and a time and date stamped on the last time they
+ * were updated and why. That way I know I'm never looking at out-of-date documents."*
+ *
+ * NOTHING HERE IS INVENTED, and that constraint is the whole design:
+ *
+ *   status   LIFTED from the document's own body. All 12 already say `**Status**: Accepted (date)`
+ *            — the information was never missing, it just sat where no tool could read it. A status
+ *            is a judgement; deriving one from git would be fabrication, so a document that does
+ *            not state its own status is REPORTED and skipped, never guessed at.
+ *   date     LIFTED from the body's `**Date**:`, falling back to git's first-commit date.
+ *   updated  DERIVED from `git log -1` — the last commit that actually touched the file. A typed
+ *            date can be wrong; a git object cannot.
+ *
+ * Every written value is therefore traceable to either the document itself or the repository's
+ * history. This matters because a fabricated timestamp is worse than a missing one: a missing
+ * stamp is visibly unknown, while a wrong stamp is confidently misleading — the exact failure mode
+ * this project has paid for repeatedly.
+ *
+ *   node scripts/adr-backfill.mjs           report what WOULD change (default; writes nothing)
+ *   node scripts/adr-backfill.mjs --apply   write it
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+const REPO = path.resolve(import.meta.dirname, '..');
+const ADR_DIR = path.join(REPO, 'docs', 'adr');
+const apply = process.argv.includes('--apply');
+
+const git = (args) => {
+  try { return execFileSync('git', args, { cwd: REPO, encoding: 'utf8' }).trim(); }
+  catch { return ''; }
+};
+
+/** First-commit date — the honest "created", when the body does not state one. */
+const gitCreated = (rel) =>
+  (git(['log', '--follow', '--diff-filter=A', '--format=%ad', '--date=short', '--', rel]).split('\n').filter(Boolean).pop() || '');
+
+/** Last commit that touched the file — the honest "updated". */
+const gitUpdated = (rel) => git(['log', '-1', '--format=%ad', '--date=short', '--', rel]);
+
+const VALID = ['Proposed', 'Accepted', 'Implemented', 'Superseded', 'Deprecated'];
+
+function parseBody(src) {
+  // `**Status**: Accepted (2026-06-27)` → Accepted, 2026-06-27
+  const sm = src.match(/^\*\*Status\*\*:\s*([A-Za-z]+)(?:\s*\((\d{4}-\d{2}-\d{2})\))?/m);
+  const dm = src.match(/^\*\*Date\*\*:\s*(\d{4}-\d{2}-\d{2})/m);
+  const status = sm && VALID.find((v) => v.toLowerCase() === sm[1].toLowerCase());
+  return { status: status || null, statusDate: sm?.[2] || null, date: dm?.[1] || null };
+}
+
+function frontmatter(src) {
+  const lines = src.split('\n');
+  if (lines[0]?.trim() !== '---') return null;
+  const end = lines.findIndex((l, i) => i > 0 && l.trim() === '---');
+  if (end < 0) return null;
+  const keys = {};
+  for (let i = 1; i < end; i++) {
+    const m = lines[i].match(/^(\w+):\s*(.*)$/);
+    if (m) keys[m[1]] = m[2];
+  }
+  return { keys, end, lines };
+}
+
+const results = [];
+for (const f of fs.readdirSync(ADR_DIR).filter((n) => /^\d{4}-.*\.md$/.test(n)).sort()) {
+  const rel = path.join('docs', 'adr', f);
+  const abs = path.join(ADR_DIR, f);
+  const src = fs.readFileSync(abs, 'utf8');
+  const fm = frontmatter(src);
+  if (!fm) { results.push({ f, skip: 'no frontmatter block to extend' }); continue; }
+
+  const body = parseBody(src);
+  const need = {};
+  if (!fm.keys.status && body.status) need.status = body.status;
+  if (!fm.keys.date) { const d = body.date || body.statusDate || gitCreated(rel); if (d) need.date = d; }
+  if (!fm.keys.updated) { const u = gitUpdated(rel); if (u) need.updated = u; }
+
+  if (!fm.keys.status && !body.status) {
+    // A status is a judgement. Refuse to guess; report it so a human can decide.
+    results.push({ f, skip: 'no status stated anywhere — a human must set this, it cannot be derived' });
+    continue;
+  }
+  if (!Object.keys(need).length) { results.push({ f, ok: true }); continue; }
+
+  if (apply) {
+    const insert = Object.entries(need).map(([k, v]) => `${k}: ${v}`);
+    const out = [...fm.lines.slice(0, fm.end), ...insert, ...fm.lines.slice(fm.end)];
+    fs.writeFileSync(abs, out.join('\n'));
+  }
+  results.push({ f, need });
+}
+
+const changed = results.filter((r) => r.need);
+const skipped = results.filter((r) => r.skip);
+console.log(`\n  ${results.length} ADR(s) · ${changed.length} ${apply ? 'updated' : 'would change'} · ${skipped.length} skipped · ${results.filter((r) => r.ok).length} already complete\n`);
+for (const r of changed) console.log(`    ${apply ? '✓' : '·'} ${r.f}  +${Object.entries(r.need).map(([k, v]) => `${k}=${v}`).join(' +')}`);
+for (const r of skipped) console.log(`    ⚠ ${r.f}  — ${r.skip}`);
+if (!apply && changed.length) console.log(`\n  Nothing written. Re-run with --apply.\n`);
+else console.log('');