ruvnet-brain 4.7.6 → 4.7.8

package/README.md

@@ -9,7 +9,7 @@ Created: 2026-06-29 22:36:38 EDT
 
 ### Discover the stack. Read the source. Build with confidence.
 
-[![RuvNet Brain version 4.6.2 — README updated 2026-10-10 EDT](https://img.shields.io/badge/version_4.7.6-updated_2026--10--10_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](plugin/.claude-plugin/plugin.json)
+[![RuvNet Brain version 4.6.2 — README updated 2026-10-10 EDT](https://img.shields.io/badge/version_4.7.8-updated_2026--10--10_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](plugin/.claude-plugin/plugin.json)
 
 **A source-grounded companion for Claude Code and Codex that helps you find and use Reuven Cohen's (rUv's) RuvNet ecosystem.**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.7.6",
+  "version": "4.7.8",
   "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": {

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
   "description": "RuvNet brain transplant for Claude Code — grounds every RuvNet decision in real source across 77 rUv repositories, prefers Ruflo / RuVector-RVF / AgentDB over training-prior defaults (pgvector, Pinecone, hand-rolled cosine), and can pull in any RuvNet repo on demand. Ships a UserPromptSubmit retrieve-and-inject grounding hook and a PreToolUse write gate that refuses ungrounded rUv-product code until search_ruvnet has been consulted (ADR-0012 / ADR-067).",
-  "version": "4.7.6",
+  "version": "4.7.8",
   "author": {
     "name": "Stuart Kerr"
   },

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.7.6",
+  "version": "4.7.8",
   "description": "Source-grounded RuvNet knowledge, lifecycle enforcement, and learning for Codex.",
   "author": {
     "name": "Stuart Kerr"

package/plugin/scripts/agentdb-recall.mjs

@@ -319,6 +319,18 @@ async function consequentialRecall({ prompt, root, store, bin, scratch, env, dea
       records: selected.map(({ category, namespace, key, storePath, valueDigest }) => ({ category, namespace, key, storePath, valueDigest })), authority: false } };
 }
 
+/**
+ * Quiet by default (2026-10-15): a recall that found nothing because it timed out or was unavailable says
+ * nothing — "Search timed out; no records verified" on every prompt under load is noise, not information.
+ * RUVNET_STOP_NUDGES=full keeps the honest status line.
+ */
+export function recallIsWorthSurfacing(r, env = process.env) {
+  if (!r?.block) return false;
+  if (String(env.RUVNET_STOP_NUDGES || '').toLowerCase() === 'full') return true;
+  if (Array.isArray(r.picks) && r.picks.length) return true;
+  return !/\b(timed[- ]out|unavailable)\b/i.test(String(r.outcome || r.status || r.block));
+}
+
 export async function recall({ prompt, projectDir = process.cwd(), env = process.env, deadlineMs, ruflo, scratch,
   binding = {}, signal, absoluteDeadline, consequential = false, enumerateKeys = enumerateCanonicalKeys } = {}) {
   const started = Date.now();
@@ -451,6 +463,7 @@ async function main() {
   const projectDir = typeof ev.cwd === 'string' && ev.cwd ? ev.cwd : process.cwd();
   const r = await recall({ prompt, projectDir, deadlineMs: Math.max(1, DEFAULT_DEADLINE_MS - (Date.now() - started)) });
   if (!r.block) return;
+  if (!recallIsWorthSurfacing(r)) return;
   const hash = crypto.createHash('sha256').update(r.block).digest('hex').slice(0, 12);
   // Hash only, never raw memory values, enters the per-session dedupe markers.
   process.stdout.write(`${hash}\n${r.block}\n`);

package/plugin/scripts/continuation-gate.mjs

@@ -390,7 +390,9 @@ const completion = (() => {
  * can never close must never be written. Per-turn and total caps; dedupe against open items by
  * normalized text; project + worktree scoped exactly like --commit-to's objective. Fails open.
  */
+const STOP_NUDGES_FULL = String(process.env.RUVNET_STOP_NUDGES || '').toLowerCase() === 'full';
 function promiseBookkeeping() {
+  if (!STOP_NUDGES_FULL) return;
   if (HOST !== 'claude' || !hookInput.session_id || hookInput.session_id === '*') return;
   try {
     const pid = projectIdentity.projectId;
@@ -728,13 +730,22 @@ const decisionWork = (() => {
 })();
 const promiseWork = HOST === 'claude'
   ? authorizedPromiseItems(led.items, hookInput, projectIdentity)
-    .map((i) => ({ text: `you said you would: ${i.text}`, at: i.at, kind: PROMISE_KIND }))
+    .map((i) => ({ text: `you said you would: ${i.text}`, at: i.at, kind: PROMISE_KIND, key: i.key }))
   : [];
 const deferralWork = deferralState?.v.verdict === 'DEFERRAL' && deferralState.forced < MAX_DEFERRAL_FORCES ? [{
   text: `your answer ends by handing authorized work back ("${deferralState.v.deferral.phrase}") although ${deferralState.v.authorization} authorizes it and no blocker is named. Do that work now`,
   at: new Date(nowMs).toISOString(), derived: true, kind: 'no-deferral' }] : [];
+/**
+ * QUIET BY DEFAULT (owner, 2026-10-15): a Stop hook that talks on ordinary turns teaches people to ignore or
+ * disable the whole product. Unless RUVNET_STOP_NUDGES=full, this gate speaks ONLY for (1) an objective the
+ * user explicitly committed it to, and (2) a RuvNet capability claim contradicted by typed evidence. Promise
+ * nudges, completion-claim corrections, decision-record reminders, deferral nags and "unknown" claims are
+ * dropped. Promises are not even captured in quiet mode: capturing work that is never nudged is only ledger
+ * bloat. `full` restores every nudge (tests and anyone who wants them).
+ */
 const open = [...capabilityClaimWork(), ...completionWork, ...decisionWork, ...deferralWork,
-  ...(objective ? [{ text: objective.text, at: objective.at }] : []), ...promiseWork];
+  ...(objective ? [{ text: objective.text, at: objective.at }] : []), ...promiseWork]
+  .filter((i) => STOP_NUDGES_FULL || !i.kind || (i.kind === 'capability-claim-integrity' && / contradicts /.test(i.text)));
 if (!open.length) process.exit(EXIT_ALLOW);   // nothing outstanding: silence is correct
 
 /**
@@ -765,7 +776,7 @@ if (!open.length) process.exit(EXIT_ALLOW);   // nothing outstanding: silence is
 // how old it is, which is information the reader needs rather than a reason to withhold. If a ledger
 // is genuinely abandoned, the honest fix is to mark its items done — not to let a clock silently
 // decide the commitment expired.
-const forceable = open.filter((i) => Number.isFinite(Date.parse(i.at)));
+let forceable = open.filter((i) => Number.isFinite(Date.parse(i.at)));
 if (!forceable.length) process.exit(EXIT_ALLOW);
 
 /**
@@ -806,6 +817,49 @@ function claimCooldown(now, windowMs) {
   catch { return false; }                                               // lost the race / cannot persist → fail closed
 }
 if (!claimCooldown(nowMs, COOLDOWN_MS)) process.exit(EXIT_ALLOW);
+
+/**
+ * BOUNDED FORCING FOR PROMISES (2026-10-15). A captured promise closes only on a verified completion
+ * claim, and that verdict can be OBSERVED_CHECK or UNKNOWN but never PASS (64b0b7ee), so an assistant
+ * promise had NO route to closure and re-forced every Stop forever — measured: 36 open promises across
+ * 7 ledgers, many garbage fragments. A gate with no way out is not rigor, it is a trap that teaches the
+ * model to stop answering.
+ *
+ * So each promise is forced at most PROMISE_MAX_FORCES times (default 3). After that it is RETAINED as
+ * state 'deferred' with the reason recorded — never marked done, never deleted — and stops forcing.
+ * The count is per promise, not a clock, so old open work is still nagged until it has had its chances.
+ * User objectives and derived (observed) items are untouched.
+ */
+const PROMISE_MAX_FORCES = Number(process.env.RUVNET_PROMISE_MAX_FORCES ?? 3);
+// Counts live BESIDE the ledger, not on its rows: a forcing stop must leave the ledger byte-identical
+// (continuation-commitment-ownership.test.mjs), and only the retirement itself may write a row.
+try {
+  const FORCES = LEDGER + '.forces.json';
+  let counts = {};
+  try { counts = JSON.parse(fs.readFileSync(FORCES, 'utf8')) || {}; } catch { /* first force */ }
+  const retired = [];
+  let touched = false;
+  for (const f of forceable) {
+    if (f.kind !== PROMISE_KIND) continue;
+    const row = led.items.find((i) => i.kind === PROMISE_KIND && i.key === f.key && !i.done
+      && (i.state === undefined || i.state === 'active'));
+    if (!row) continue;
+    const id = crypto.createHash('sha256').update(JSON.stringify([row.projectId, row.sessionIds, row.key])).digest('hex').slice(0, 24);
+    const n = (counts[id]?.n || 0) + 1;
+    counts[id] = { n, at: new Date(nowMs).toISOString() };
+    touched = true;
+    if (n > PROMISE_MAX_FORCES) {
+      Object.assign(row, { state: 'deferred', stateAt: new Date(nowMs).toISOString(),
+        stateReason: `forced ${PROMISE_MAX_FORCES} times with no verified completion claim; retained, not completed` });
+      retired.push(f);
+      delete counts[id];
+    }
+  }
+  for (const [k, v] of Object.entries(counts)) if (nowMs - Date.parse(v?.at) > 14 * 86_400_000) delete counts[k];
+  if (touched) fs.writeFileSync(FORCES, JSON.stringify(counts));
+  if (retired.length) { save(led); forceable = forceable.filter((i) => !retired.includes(i)); }
+} catch { /* bookkeeping only: never break a turn */ }
+if (!forceable.length) process.exit(EXIT_ALLOW);
 if (deferralState && forceable.some((i) => i.kind === 'no-deferral')) {
   try { for (const [k, v] of Object.entries(deferralState.counts)) if (nowMs - Date.parse(v?.at) > 7 * 86_400_000) delete deferralState.counts[k];
     deferralState.counts[deferralState.chain] = { n: deferralState.forced + 1, at: new Date(nowMs).toISOString() };

package/plugin/scripts/decision-gate.mjs

@@ -31,6 +31,8 @@ import { append as appendOutcome, actionKey, recordRefusal, resolve as resolveOu
 // see a host-native spelling — the 4.4 measurement was a Grok write silently allowed. hook-input.mjs.
 import { normalizePayloadText } from './hook-input.mjs';
 
+const QUIET_FULL = String(process.env.RUVNET_STOP_NUDGES || '').toLowerCase() === 'full';
+
 const SCRIPTS_DIR = path.dirname(fileURLToPath(import.meta.url));
 const EVENT = process.argv[2] || '';
 
@@ -415,7 +417,10 @@ function reportBudget({ session, unconsulted, trace, started, budgetMs, refused
   try {
     appendOutcome({ kind: 'budget-exceeded', event: EVENT, session, unconsulted, elapsedMs: elapsed, budgetMs, ts: Date.now() });
   } catch { /* a ledger must never break a tool call */ }
-  process.stderr.write(
+  // Quiet by default (2026-10-15): the outcome is already in the ledger above. On an ALLOW, a stderr line only
+  // makes the host show a hook "error" for a decision that was made. It is kept when the action was refused
+  // and under RUVNET_STOP_NUDGES=full.
+  if (refused || QUIET_FULL) process.stderr.write(
     `[decision-gate] ${budgetMs}ms budget exhausted after ${elapsed}ms — ${refused ? 'REFUSED; UNCONSULTED' : 'ALLOWED WITHOUT CONSULTING'}: `
     + `${unconsulted.join(', ')}. These policies did not vote; ${refused ? 'another policy refused the action.' : 'this allow is a timeout, not a verdict.'}\n`,
   );
@@ -424,7 +429,7 @@ function reportBudget({ session, unconsulted, trace, started, budgetMs, refused
 function reportSelfSkipped({ session, selfSkipped }) {
   for (const r of selfSkipped) {
     try { appendOutcome({ kind: 'policy-skipped', event: EVENT, session, policy: r.id, reason: r.reason, ts: Date.now() }); } catch { /* a ledger must never break a tool call */ }
-    process.stderr.write(`[decision-gate] ${r.reason || `${r.id} skipped`} — ${r.id} did not vote; it supplied no authorization verdict.\n`);
+    if (QUIET_FULL) process.stderr.write(`[decision-gate] ${r.reason || `${r.id} skipped`} — ${r.id} did not vote; it supplied no authorization verdict.\n`);
   }
 }
 /**

package/plugin/scripts/grounding-turn-gate.mjs

@@ -206,6 +206,9 @@ export function decide({ hookInput, marker, markerMs, searchEvidence = null, own
 async function main() {
   const hookInput = await readStopHookInput();
   if (hookInput.__source !== 'stdin') process.exit(EXIT_ALLOW);
+  // Quiet by default (2026-10-15): the "answered without searching" correction is a nudge, not a safety stop.
+  // RUVNET_STOP_NUDGES=full restores it.
+  if (String(process.env.RUVNET_STOP_NUDGES || '').toLowerCase() !== 'full') process.exit(EXIT_ALLOW);
   if (hookInput.stop_hook_active && !hookInput.interrupted && !hookInput.cancelled) process.exit(EXIT_ALLOW);
   if (hookInput.hook_event_name !== 'Stop') {
     process.exit(EXIT_ALLOW);

package/plugin/scripts/hook-shim.mjs

@@ -209,6 +209,15 @@ if (!entry) {
 // forgets to declare one fails toward the pre-ADR-054 behaviour rather than toward silent death.
 if (BRAIN_OFF && entry.offBehavior === 'silence') process.exit(0);
 
+// QUIET BY DEFAULT (owner, 2026-10-15). These advisory hooks only ever add text to a turn (advocacy offers,
+// "ADRs are living plans", MetaHarness/QE offers, parallel-work sizing, the answered-without-searching
+// nudge). None of them blocks or protects anything, and together they were the constant noise on every
+// prompt. They stay registered and run only when RUVNET_STOP_NUDGES=full, so nothing is deleted and the
+// tests still exercise them. The blocking hooks (decision-gate), the grounding directive and the silent
+// capture hooks are unaffected.
+const QUIET_BY_DEFAULT = new Set(['unprompted-speech', 'capacity-aware-parallel-work', 'grounding-turn-gate']);
+if (QUIET_BY_DEFAULT.has(hookId) && String(process.env.RUVNET_STOP_NUDGES || '').toLowerCase() !== 'full') process.exit(0);
+
 // Read a bounded payload before dispatch. The ground body owns the quiet-prompt
 // decision because it resolves canonical memory beyond the hook process's cwd.
 let hookInput = null;

package/plugin/scripts/learning-store.mjs

@@ -8,6 +8,7 @@ import { resolveProjectStore } from './project-store-resolver.mjs';
 import { rufloInvocation, rufloRunDir, resolveRuflo } from './ruflo-bin.mjs';
 import { loadRuntimePreferences } from './runtime-preferences.mjs';
 import { learningContext } from './runtime-preferences.mjs';
+import { captureFailureReason } from './turn-capture-privacy.mjs';
 
 export const LEARNING_NAMESPACE = 'learning-observations';
 export function learningTarget(context, { env = process.env, explicitLegacyApply = false } = {}) {
@@ -56,7 +57,7 @@ export function recordLearningObservation(binary, context, { tool, action, sessi
   // A refused store whose key already holds these exact bytes is the dedupe working, not a failure.
   if (stored.error || stored.status !== 0) {
     if (exact) return { db, key, digest: createHash('sha256').update(value).digest('hex'), exactCli: true, alreadyStored: true };
-    throw new Error(`ruflo memory store refused the observation: ${String(stored.stderr || stored.stdout || stored.error?.message || '').trim().slice(0, 160)}`);
+    throw new Error(`ruflo memory store refused the observation: ${captureFailureReason(stored, stored.status)}`);
   }
   if (!exact) throw new Error('canonical exact CLI readback failed');
   return { db, key, digest: createHash('sha256').update(value).digest('hex'), exactCli: true };

package/plugin/scripts/session-start-update-plane.mjs

@@ -229,6 +229,17 @@ export const heartbeat = ({ env, hookDir, stateDir, home, running, seedDispatche
   dispatchDetached(hookDir, 10, versionLog, process.execPath,
     [path.join(hookDir, 'host-update.mjs'), '--check'], env);
   if (!running || !remoteVersion || remoteVersion === running) return;
+  // `running` is the version this session BOOTED with. After the Stable Spine flips, the active generation can
+  // already be the remote version (or newer): "vX is downloading" beside "vX active" is a false statement
+  // (D5, 2026-10-15). Only announce a download when the remote is strictly newer than what is active now.
+  try {
+    const active = JSON.parse(read(path.join(home, '.cache', 'ruvnet-brain', 'active.json')) || '{}').version;
+    const parts = (v) => String(v || '').split(/[.-]/).map((x) => (/^\d+$/.test(x) ? Number(x) : 0));
+    const [a, r] = [parts(active), parts(remoteVersion)];
+    let newer = false;
+    for (let i = 0; i < 3 && active; i += 1) { if ((r[i] || 0) !== (a[i] || 0)) { newer = (r[i] || 0) > (a[i] || 0); break; } }
+    if (active && !newer) return;
+  } catch { /* unknown active generation: keep the existing announcement */ }
   if (pref === 'yes' && exists(path.join(hookDir, 'host-update.mjs'))) {
     dispatchDetached(hookDir, 600, path.join(stateDir, '.last-auto-update.log'),
       process.execPath, [path.join(hookDir, 'host-update.mjs')], env);